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 # output
 334
 335
 336 class A:
 337     def foo():
 338         result = type(message)("")
 339
 340
 341 # Don't merge multiline (e.g. triple-quoted) strings.
 342 def foo():
 343     query = (
 344         """SELECT xxxxxxxxxxxxxxxxxxxx(xxx)"""
 345         """ FROM xxxxxxxxxxxxxxxx WHERE xxxxxxxxxx AND xxx <> xxxxxxxxxxxxxx()"""
 346     )
 347
 348
 349 # There was a bug where tuples were being identified as long strings.
 350 long_tuple = (
 351     "Apple",
 352     "Berry",
 353     "Cherry",
 354     "Dill",
 355     "Evergreen",
 356     "Fig",
 357     "Grape",
 358     "Harry",
 359     "Iglu",
 360     "Jaguar",
 361 )
 362
 363 stupid_format_method_bug = (
 364     "Some really long string that just so happens to be the {} {} to force the 'format'"
 365     " method to hang over the line length boundary. This is pretty annoying.".format(
 366         "perfect", "length"
 367     )
 368 )
 369
 370
 371 class A:
 372     def foo():
 373         os.system(
 374             "This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx"
 375             " xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx"
 376             " xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx")
 377         )
 378
 379
 380 class A:
 381     def foo():
 382         XXXXXXXXXXXX.append(
 383             (
 384                 "xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx, xxxx_xxxx_xxxxxxxxxx={})"
 385                 .format(xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx),
 386                 my_var,
 387                 my_other_var,
 388             )
 389         )
 390
 391
 392 class A:
 393     class B:
 394         def foo():
 395             bar(
 396                 "[{}]: xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx={}"
 397                 " xxxx_xxxx_xxxxxxxxxx={}, xxxx={})".format(
 398                     xxxx._xxxxxxxxxxxxxx, xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx, xxxxxxx
 399                 ),
 400                 varX,
 401                 varY,
 402                 varZ,
 403             )
 404
 405
 406 def foo(xxxx):
 407     for (xxx_xxxx, _xxx_xxx, _xxx_xxxxx, xxx_xxxx) in xxxx:
 408         for xxx in xxx_xxxx:
 409             assert ("x" in xxx) or (xxx in xxx_xxx_xxxxx), (
 410                 "{0} xxxxxxx xx {1}, xxx {1} xx xxx xx xxxx xx xxx xxxx: xxx xxxx {2}"
 411                 .format(xxx_xxxx, xxx, xxxxxx.xxxxxxx(xxx_xxx_xxxxx))
 412             )
 413
 414
 415 class A:
 416     def disappearing_comment():
 417         return (
 418             (  # xx -x xxxxxxx xx xxx xxxxxxx.
 419                 "{{xxx_xxxxxxxxxx_xxxxxxxx}} xxx xxxx {} {{xxxx}} >&2".format(
 420                     "{xxxx} {xxxxxx}"
 421                     if xxxxx.xx_xxxxxxxxxx
 422                     else (  # Disappearing Comment
 423                         "--xxxxxxx --xxxxxx=x --xxxxxx-xxxxx=xxxxxx"
 424                         " --xxxxxx-xxxx=xxxxxxxxxxx.xxx"
 425                     )
 426                 )
 427             ),
 428             (x, y, z),
 429         )
 430
 431
 432 class A:
 433     class B:
 434         def foo():
 435             xxxxx_xxxx(
 436                 xx,
 437                 "\t"
 438                 "@xxxxxx '{xxxx_xxx}\t' > {xxxxxx_xxxx}.xxxxxxx;"
 439                 "{xxxx_xxx} >> {xxxxxx_xxxx}.xxxxxxx 2>&1; xx=$$?;"
 440                 "xxxx $$xx".format(
 441                     xxxx_xxx=xxxx_xxxxxxx,
 442                     xxxxxx_xxxx=xxxxxxx + "/" + xxxx_xxx_xxxx,
 443                     x=xxx_xxxxx_xxxxx_xxx,
 444                 ),
 445                 x,
 446                 y,
 447                 z,
 448             )
 449
 450
 451 func_call_where_string_arg_has_method_call_and_bad_parens(
 452     "A long string with {}. This string is so long that it is ridiculous. It can't fit"
 453     " on one line at alllll.".format("formatting"),
 454 )
 455
 456 func_call_where_string_arg_has_old_fmt_and_bad_parens(
 457     "A long string with {}. This string is so long that it is ridiculous. It can't fit"
 458     " on one line at alllll." % "formatting",
 459 )
 460
 461 func_call_where_string_arg_has_old_fmt_and_bad_parens(
 462     "A long string with {}. This {} is so long that it is ridiculous. It can't fit on"
 463     " one line at alllll." % ("formatting", "string"),
 464 )
 465
 466
 467 class A:
 468     def append(self):
 469         if True:
 470             xxxx.xxxxxxx.xxxxx(
 471                 "xxxxxxxxxx xxxx xx xxxxxx(%x) xx %x xxxx xx xxx %x.xx"
 472                 % (len(self) + 1, xxxx.xxxxxxxxxx, xxxx.xxxxxxxxxx)
 473                 + " %.3f (%s) to %.3f (%s).\n"
 474                 % (
 475                     xxxx.xxxxxxxxx,
 476                     xxxx.xxxxxxxxxxxxxx(xxxx.xxxxxxxxx),
 477                     x,
 478                     xxxx.xxxxxxxxxxxxxx(xx),
 479                 )
 480             )
 481
 482
 483 class A:
 484     def foo():
 485         some_func_call(
 486             "xxxxxxxxxx",
 487             "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 488             '"xxxx xxxxxxx xxxxxx xxxx; xxxx xxxxxx_xxxxx xxxxxx xxxx; '
 489             "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ",
 490             None,
 491             ("xxxxxxxxxxx",),
 492         ),
 493
 494
 495 class A:
 496     def foo():
 497         some_func_call(
 498             "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 499             "xxxx, ('xxxxxxx xxxxxx xxxx, xxxx') xxxxxx_xxxxx xxxxxx xxxx; "
 500             "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ",
 501             None,
 502             ("xxxxxxxxxxx",),
 503         ),
 504
 505
 506 xxxxxxx = {
 507     "xx": (
 508         "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx"
 509         " xxx=xxx_xxxx,xxx_xx,xxx_xxx,xxx_xxxx,xxx_xx,xxx_xxx | xxxxxx -x xxxxxxxx -x"
 510         " xxxxxxxx -x"
 511     ),
 512     "xx": (
 513         "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx"
 514         " xxx=xxx_xxxx_xxx_xxxx,xxx_xx_xxx_xxxx,xxx_xxxx_xxx_xxxx,xxx_xx_xxxx_xxxx,xxx_xxx_xxxx,xxx_xxx_xxxx"
 515         " xxxx=xxx | xxxxxx -x xxxxxxxx -x xxxxxxxx -x"
 516     ),
 517 }
 518
 519
 520 class A:
 521     def foo(self):
 522         if True:
 523             xxxxx_xxxxxxxxxxxx(
 524                 "xxx xxxxxx xxx xxxxxxxxx.xx xx xxxxxxxx.  xxx xxxxxxxxxxxxx.xx"
 525                 " xxxxxxx "
 526                 + "xx xxxxxx xxxxxx xxxxxx xx xxxxxxx xxx xxx ${0} xx x xxxxxxxx xxxxx"
 527                 .xxxxxx(xxxxxx_xxxxxx_xxx)
 528             )
 529
 530
 531 class A:
 532     class B:
 533         def foo():
 534             row = {
 535                 "xxxxxxxxxxxxxxx": xxxxxx_xxxxx_xxxx,
 536                 # 'xxxxxxxxxxxxxxxxxxxxxxx'
 537                 # 'xxxxxxxxxxxxxxxxxxxxxx'
 538                 # 'xxxxxxxxxxxxxxxxxx'
 539                 # 'xxxxxxxxxxxxxxxxx'
 540                 "xxxxxxxxxx": xxxxx_xxxxx,
 541             }
 542
 543
 544 class A:
 545     def xxxx_xxx_xx_xxxxxxxxxx_xxxx_xxxxxxxxx(xxxx):
 546         xxxxxxxx = [
 547             xxxxxxxxxxxxxxxx(
 548                 "xxxx",
 549                 xxxxxxxxxxx={
 550                     "xxxx": 1.0,
 551                 },
 552                 xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=600.0)},
 553                 xxxxxxxx_xxxxxxx=0.0,
 554             ),
 555             xxxxxxxxxxxxxxxx(
 556                 "xxxxxxx",
 557                 xxxxxxxxxxx={
 558                     "xxxx": 1.0,
 559                 },
 560                 xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=200.0)},
 561                 xxxxxxxx_xxxxxxx=0.0,
 562             ),
 563             xxxxxxxxxxxxxxxx(
 564                 "xxxx",
 565             ),
 566         ]
 567
 568
 569 some_dictionary = {
 570     "xxxxx006": [
 571         "xxx-xxx"
 572         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx=="
 573         " xxxxx000 xxxxxxxxxx\n",
 574         "xxx-xxx"
 575         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx=="
 576         " xxxxx010 xxxxxxxxxx\n",
 577     ],
 578     "xxxxx016": [
 579         "xxx-xxx"
 580         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx=="
 581         " xxxxx000 xxxxxxxxxx\n",
 582         "xxx-xxx"
 583         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx=="
 584         " xxxxx010 xxxxxxxxxx\n",
 585     ],
 586 }
 587
 588
 589 def foo():
 590     xxx_xxx = (  # xxxx xxxxxxxxxx xxxx xx xxxx xx xxx xxxxxxxx xxxxxx xxxxx.
 591         'xxxx xxx xxxxxxxx_xxxx xx "xxxxxxxxxx".\n xxx: xxxxxx xxxxxxxx_xxxx=xxxxxxxxxx'
 592     )
 593
 594
 595 some_tuple = ("some string", "some string which should be joined")
 596
 597 some_commented_string = (  # This comment gets thrown to the top.
 598     "This string is long but not so long that it needs hahahah toooooo be so greatttt"
 599     " {} that I just can't think of any more good words to say about it at"
 600     " allllllllllll".format("ha")  # comments here are fine
 601 )
 602
 603 some_commented_string = (
 604     "This string is long but not so long that it needs hahahah toooooo be so greatttt"  # But these
 605     " {} that I just can't think of any more good words to say about it at"  # comments will stay
 606     " allllllllllll".format("ha")  # comments here are fine
 607 )
 608
 609 lpar_and_rpar_have_comments = func_call(  # LPAR Comment
 610     "Long really ridiculous type of string that shouldn't really even exist at all. I"
 611     " mean commmme onnn!!!",  # Comma Comment
 612 )  # RPAR Comment
 613
 614 cmd_fstring = (
 615     "sudo -E deluge-console info --detailed --sort-reverse=time_added "
 616     f"{'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 617 )
 618
 619 cmd_fstring = (
 620     "sudo -E deluge-console info --detailed --sort-reverse=time_added"
 621     f" {'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 622 )
 623
 624 cmd_fstring = (
 625     "sudo -E deluge-console info --detailed --sort-reverse=time_added"
 626     f" {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 627 )
 628
 629 cmd_fstring = (
 630     "sudo -E deluge-console info --detailed --sort-reverse=time_added {'' if ID is"
 631     f" None else ID}} | perl -nE 'print if /^{field}:/'"
 632 )
 633
 634 fstring = (
 635     "This string really doesn't need to be an {{fstring}}, but this one most"
 636     f" certainly, absolutely {does}."
 637 )
 638
 639 fstring = f"We have to remember to escape {braces}. Like {{these}}. But not {this}."
 640
 641
 642 class A:
 643     class B:
 644         def foo():
 645             st_error = STError(
 646                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
 647                 " no parent)."
 648             )
 649
 650
 651 def foo():
 652     user_regex = _lazy_re_compile(
 653         r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z"  # dot-atom
 654         r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"\Z)',  # quoted-string
 655         re.IGNORECASE,
 656     )
 657
 658
 659 def foo():
 660     user_regex = _lazy_re_compile(
 661         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 662         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # quoted-string
 663         xyz,
 664     )
 665
 666
 667 def foo():
 668     user_regex = _lazy_re_compile(
 669         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 670         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # quoted-string
 671         xyz,
 672     )
 673
 674
 675 class A:
 676     class B:
 677         def foo():
 678             if not hasattr(module, name):
 679                 raise ValueError(
 680                     "Could not find object %s in %s.\n"
 681                     "Please note that you cannot serialize things like inner "
 682                     "classes. Please move the object into the main module "
 683                     "body to use migrations.\n"
 684                     "For more information, see "
 685                     "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 686                     % (name, module_name, get_docs_version())
 687                 )
 688
 689
 690 class A:
 691     class B:
 692         def foo():
 693             if not hasattr(module, name):
 694                 raise ValueError(
 695                     "Could not find object %s in %s.\nPlease note that you cannot"
 696                     " serialize things like inner classes. Please move the object into"
 697                     " the main module body to use migrations.\nFor more information,"
 698                     " see https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 699                     % (name, module_name, get_docs_version())
 700                 )
 701
 702
 703 x = (
 704     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 705     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 706     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 707     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 708 )
 709
 710
 711 class Step(StepBase):
 712     def who(self):
 713         self.cmd = (
 714             "SR AAAA-CORRECT NAME IS {last_name} {first_name}{middle_name}"
 715             " {title}/P{passenger_association}".format(
 716                 last_name=last_name,
 717                 first_name=first_name,
 718                 middle_name=middle_name,
 719                 title=title,
 720                 passenger_association=passenger_association,
 721             )
 722         )
 723
 724
 725 xxxxxxx_xxxxxx_xxxxxxx = xxx(
 726     [
 727         xxxxxxxxxxxx(
 728             xxxxxx_xxxxxxx=(
 729                 '((x.aaaaaaaaa = "xxxxxx.xxxxxxxxxxxxxxxxxxxxx") || (x.xxxxxxxxx ='
 730                 ' "xxxxxxxxxxxx")) && '
 731                 # xxxxx xxxxxxxxxxxx xxxx xxx (xxxxxxxxxxxxxxxx) xx x xxxxxxxxx xx xxxxxx.
 732                 "(x.bbbbbbbbbbbb.xxx != "
 733                 '"xxx:xxx:xxx::cccccccccccc:xxxxxxx-xxxx/xxxxxxxxxxx/xxxxxxxxxxxxxxxxx") && '
 734             )
 735         )
 736     ]
 737 )
 738
 739 if __name__ == "__main__":
 740     for i in range(4, 8):
 741         cmd = (
 742             r"for pid in $(ps aux | grep paster | grep -v grep | grep '\-%d' | awk"
 743             r" '{print $2}'); do kill $pid; done" % (i)
 744         )