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