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