o h@sdZddlmZddlmZddlmZmZm Z GdddeZ GdddeZ Gd d d eZ Gd d d eZ Gd ddeZdS)z& Tests for various Pyflakes behavior. ) version_info)messages)TestCaseskipskipIfc@seZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAdBZ#dCdDZ$dEdFZ%dGdHZ&dIdJZ'dKdLZ(dMdNZ)e*dOdPdQZ+dRdSZ,dTdUZ-dVdWZ.dXdYZ/dZd[Z0d\d]Z1d^d_Z2d`daZ3dbdcZ4dddeZ5dfdgZ6dhdiZ7djdkZ8dlS)mTestcC|dtjdS)Nzdef fu(bar, bar): pass)flakesmDuplicateArgumentselfrN/var/www/html/ai/venv/lib/python3.10/site-packages/pyflakes/test/test_other.pytest_duplicateArgs szTest.test_duplicateArgscCs|dtjtjdS)NzG a = 1 def f(): a; a=1 f() )r r UndefinedLocalUnusedVariabler rrr$test_localReferencedBeforeAssignmentsz)Test.test_localReferencedBeforeAssignmentcC:|d|d|dtj|d|ddS)z_ Test that reusing a variable in a generator does not raise a warning. z8 a = 1 (1 for a, b in [(1, 2)]) zU class A: a = 1 list(1 for a, b in [(1, 2)]) zQ def f(): a = 1 (1 for a, b in [(1, 2)]) zK (1 for a, b in [(1, 2)]) (1 for a, b in [(1, 2)]) zY for a, b in [(1, 2)]: pass (1 for a, b in [(1, 2)]) Nr r rr rrrtest_redefinedInGenerator   zTest.test_redefinedInGeneratorcCr)zg Test that reusing a variable in a set comprehension does not raise a warning. z8 a = 1 {1 for a, b in [(1, 2)]} zQ class A: a = 1 {1 for a, b in [(1, 2)]} zQ def f(): a = 1 {1 for a, b in [(1, 2)]} zK {1 for a, b in [(1, 2)]} {1 for a, b in [(1, 2)]} zY for a, b in [(1, 2)]: pass {1 for a, b in [(1, 2)]} Nrr rrr test_redefinedInSetComprehension5rz%Test.test_redefinedInSetComprehensioncCr)zh Test that reusing a variable in a dict comprehension does not raise a warning. z< a = 1 {1: 42 for a, b in [(1, 2)]} zU class A: a = 1 {1: 42 for a, b in [(1, 2)]} zU def f(): a = 1 {1: 42 for a, b in [(1, 2)]} zS {1: 42 for a, b in [(1, 2)]} {1: 42 for a, b in [(1, 2)]} z] for a, b in [(1, 2)]: pass {1: 42 for a, b in [(1, 2)]} Nrr rrr!test_redefinedInDictComprehensionRrz&Test.test_redefinedInDictComprehensioncC|dtjdS)zf Test that shadowing a function definition with another one raises a warning. z5 def a(): pass def a(): pass Nr r RedefinedWhileUnusedr rrrtest_redefinedFunctionozTest.test_redefinedFunctioncCr)Nz- x = 1 def x(): pass rr rrr(test_redefined_function_shadows_variableyz-Test.test_redefined_function_shadows_variablecC|ddS)zq Test that shadowing a function definition named with underscore doesn't raise anything. z5 def _(): pass def _(): pass Nr r rrr test_redefinedUnderscoreFunctionz%Test.test_redefinedUnderscoreFunctioncCr)zQ Test that shadowing an underscore importation raises a warning. z; from .i18n import _ def _(): pass Nrr rrr#test_redefinedUnderscoreImportationz(Test.test_redefinedUnderscoreImportationcCr)zw Test that shadowing a function definition in a class suite with another one raises a warning. zN class A: def a(): pass def a(): pass Nrr rrrtest_redefinedClassFunctionz Test.test_redefinedClassFunctioncCr!)z{ Test that shadowing a function definition twice in an if and else block does not raise a warning. z\ if True: def a(): pass else: def a(): pass Nr"r rrrtest_redefinedIfElseFunctionr$z!Test.test_redefinedIfElseFunctioncCr)zh Test that shadowing a function definition within an if block raises a warning. zN if True: def a(): pass def a(): pass Nrr rrrtest_redefinedIfFunctionr(zTest.test_redefinedIfFunctioncCr!)z{ Test that shadowing a function definition twice in try and except block does not raise a warning. zZ try: def a(): pass except: def a(): pass Nr"r rrrtest_redefinedTryExceptFunctionr$z$Test.test_redefinedTryExceptFunctioncCr)zh Test that shadowing a function definition within a try block raises a warning. zk try: def a(): pass def a(): pass except: pass Nrr rrrtest_redefinedTryFunctionszTest.test_redefinedTryFunctioncCr!)z Test that shadowing a variable in a list comprehension in an if and else block does not raise a warning. zY if False: a = 1 else: [a for a in '12'] Nr"r rrrtest_redefinedIfElseInListCompr$z#Test.test_redefinedIfElseInListCompcCr!)z Test that shadowing a function definition with a decorated version of that function does not raise a warning. zi from somewhere import somedecorator def a(): pass a = somedecorator(a) Nr"r rrrtest_functionDecoratorr$zTest.test_functionDecoratorcCr!)z Test that shadowing a function definition in a class suite with a decorated version of that function does not raise a warning. zS class A: def a(): pass a = classmethod(a) Nr"r rrrtest_classFunctionDecoratorr$z Test.test_classFunctionDecoratorcC|ddS)Nz class A: @property def t(self): pass @t.setter def t(self, value): pass @t.deleter def t(self): pass r"r rrrtest_modernPropertyzTest.test_modernPropertycCr!)zDon't die on unary +.z+1Nr"r rrrtest_unaryPluszTest.test_unaryPluscCr)zn If a name in the base list of a class definition is undefined, a warning is emitted. z2 class foo(foo): pass Nr r UndefinedNamer rrrtest_undefinedBaseClassrzTest.test_undefinedBaseClasscCr)z If a class name is used in the body of that class's definition and the name is not already defined, a warning is emitted. z, class foo: foo Nr5r rrr"test_classNameUndefinedInClassBody rz'Test.test_classNameUndefinedInClassBodycCr!)z If a class name is used in the body of that class's definition and the name was previously defined in some other way, no warning is emitted. z? foo = None class foo: foo Nr"r rrrtest_classNameDefinedPreviouslyz$Test.test_classNameDefinedPreviouslycCr)zW If a class is defined twice in the same module, a warning is emitted. zQ class Foo: pass class Foo: pass Nrr rrrtest_classRedefinition"zTest.test_classRedefinitioncCr)zN If a function is redefined as a class, a warning is emitted. zQ def Foo(): pass class Foo: pass Nrr rrrtest_functionRedefinedAsClass-r<z"Test.test_functionRedefinedAsClasscCr)zN If a class is redefined as a function, a warning is emitted. zQ class Foo: pass def Foo(): pass Nrr rrrtest_classRedefinedAsFunction8r<z"Test.test_classRedefinedAsFunctioncCr)zK If a return is used inside a class, a warning is emitted. z7 class Foo(object): return Nr r ReturnOutsideFunctionr rrrtest_classWithReturnCr&zTest.test_classWithReturncCr)zP If a return is used at the module level, a warning is emitted. z return Nr?r rrrtest_moduleWithReturnLzTest.test_moduleWithReturncCr)zJ If a yield is used inside a class, a warning is emitted. z6 class Foo(object): yield Nr r YieldOutsideFunctionr rrrtest_classWithYieldTr&zTest.test_classWithYieldcCr)zO If a yield is used at the module level, a warning is emitted. z yield NrDr rrrtest_moduleWithYield]rCzTest.test_moduleWithYieldcCr)zO If a yield from is used inside a class, a warning is emitted. zE class Foo(object): yield from range(10) NrDr rrrtest_classWithYieldFromer&zTest.test_classWithYieldFromcCr)zT If a yield from is used at the module level, a warning is emitted. z& yield from range(10) NrDr rrrtest_moduleWithYieldFromnrCzTest.test_moduleWithYieldFromcCsX|dtj|dtj|dtj|dtj|dtj|dtjdS)Nz continue z/ def f(): continue zQ while True: pass else: continue z while True: pass else: if 1: if 2: continue zK while True: def f(): continue zK while True: class A: continue )r r ContinueOutsideLoopr rrrtest_continueOutsideLoopvs$ zTest.test_continueOutsideLoopcCs@|d|d|d|d|d|ddS)Nz2 while True: continue z: for i in range(10): continue zH while True: if 1: continue zP for i in range(10): if 1: continue z while True: while True: pass else: continue else: pass z while True: try: pass finally: while True: continue r"r rrrtest_continueInsideLoops      zTest.test_continueInsideLoopcCsf|dtj|dtj|dtj|dtj|dtj|dtj|dtjdS)Nz break z, def f(): break zN while True: pass else: break z~ while True: pass else: if 1: if 2: break zH while True: def f(): break zH while True: class A: break zJ try: pass finally: break )r r BreakOutsideLoopr rrrtest_breakOutsideLoops* zTest.test_breakOutsideLoopcCsT|d|d|d|d|d|d|d|ddS) Nz/ while True: break z7 for i in range(10): break zE while True: if 1: break zM for i in range(10): if 1: break z while True: while True: pass else: break else: pass z while True: try: pass finally: while True: break zn while True: try: pass finally: break z while True: try: pass finally: if 1: if 2: break r"r rrrtest_breakInsideLoops      zTest.test_breakInsideLoopcCs@|d|d|d|d|d|ddS)a# A default except block should be last. YES: try: ... except Exception: ... except: ... NO: try: ... except: ... except Exception: ... zS try: pass except ValueError: pass zt try: pass except ValueError: pass except: pass zH try: pass except: pass zr try: pass except ValueError: pass else: pass zg try: pass except: pass else: pass z try: pass except ValueError: pass except: pass else: pass Nr"r rrrtest_defaultExceptLast/s     zTest.test_defaultExceptLastcCs|dtj|dtj|dtj|dtjtj|dtj|dtj|dtj|dtjtj|d tj|d tj|d tj|d tjtj|d tj|dtj|dtj|dtjtjdS)Nzt try: pass except: pass except ValueError: pass zi try: pass except: pass except: pass z try: pass except: pass except ValueError: pass except: pass z try: pass except: pass except ValueError: pass except: pass except ValueError: pass z try: pass except: pass except ValueError: pass else: pass z try: pass except: pass except: pass else: pass z try: pass except: pass except ValueError: pass except: pass else: pass z try: pass except: pass except ValueError: pass except: pass except ValueError: pass else: pass z try: pass except: pass except ValueError: pass finally: pass z try: pass except: pass except: pass finally: pass z try: pass except: pass except ValueError: pass except: pass finally: pass z try: pass except: pass except ValueError: pass except: pass except ValueError: pass finally: pass z try: pass except: pass except ValueError: pass else: pass finally: pass z try: pass except: pass except: pass else: pass finally: pass z try: pass except: pass except ValueError: pass except: pass else: pass finally: pass a try: pass except: pass except ValueError: pass except: pass except ValueError: pass else: pass finally: pass )r r DefaultExceptNotLastr rrrtest_defaultExceptNotLastys`                         zTest.test_defaultExceptNotLastcCs|d|d|d|d|d|d|d|d|d d d d td Dd}||dd dd td Dd}||dd dd td Dd}||dS)z6 Python 3 extended iterable unpacking z# a, *b = range(10) z# *a, b = range(10) z& a, *b, c = range(10) z% (a, *b) = range(10) z% (*a, b) = range(10) z( (a, *b, c) = range(10) z% [a, *b] = range(10) z% [*a, b] = range(10) z( [a, *b, c] = range(10) , cs|]}d|VqdSza%dNr.0irrr kz5Test.test_starredAssignmentNoError..z, *rest = range(1<<8)(csrTrUrrVrrrrYorZz, *rest) = range(1<<8)[csrTrUrrVrrrrYsrZz, *rest] = range(1<<8)N)r joinranger srrrtest_starredAssignmentNoErrorBs*           z"Test.test_starredAssignmentNoErrorcCsdddtdDd}||tjddddtdDd}||tjd dd dtdDd }||tjdd dtd Dd}||tjddddtd Dd}||tjd dddtd Dd}||tj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtjdS)zp SyntaxErrors (not encoded in the ast) surrounding Python 3 extended iterable unpacking rScsrTrUrrVrrrrY}rZz4Test.test_starredAssignmentErrors..z, *rest = range(1<<8 + 1)r\csrTrUrrVrrrrYrZz, *rest) = range(1<<8 + 1)r]csrTrUrrVrrrrYrZz, *rest] = range(1<<8 + 1)csrTrUrrVrrrrYrZiz, *rest = range(1<<8 + 2)csrTrUrrVrrrrYrZz, *rest) = range(1<<8 + 2)csrTrUrrVrrrrYrZz, *rest] = range(1<<8 + 2)z' a, *b, *c = range(10) z* a, *b, c, *d = range(10) z( *a, *b, *c = range(10) z) (a, *b, *c) = range(10) z, (a, *b, c, *d) = range(10) z* (*a, *b, *c) = range(10) z) [a, *b, *c] = range(10) z, [a, *b, c, *d] = range(10) z* [*a, *b, *c] = range(10) N)r^r_r r %TooManyExpressionsInStarredAssignmentTwoStarredExpressionsr`rrrtest_starredAssignmentErrorswsfz!Test.test_starredAssignmentErrorsz= y x > y Nr"r rrrtest_comparisonr$zTest.test_comparisoncCr!)zn If a defined name is used on either side of an identity test, no warning is emitted. zI x = 10 y = 20 x is y x is not y Nr"r rrr test_identityr$zTest.test_identitycCr!)zp If a defined name is used on either side of a containment test, no warning is emitted. zI x = 10 y = 20 x in y x not in y Nr"r rrrtest_containmentr$zTest.test_containmentcCs|d|ddS)z> break and continue statements are supported. z4 for x in [1, 2]: break z7 for x in [1, 2]: continue Nr"r rrrtest_loopControls zTest.test_loopControlcCr!)z3 Ellipsis in a slice is supported. z [1, 2][...] Nr"r rrr test_ellipsiszTest.test_ellipsiscCr!)z0 Extended slices are supported. z+ x = 3 [1, 2][x,:] Nr"r rrrtest_extendedSlicerozTest.test_extendedSlicecCr!)zh Augmented assignment of a variable is supported. We don't care about var refs. z* foo = 0 foo += 1 Nr"r rrrtest_varAugmentedAssignment%r$z Test.test_varAugmentedAssignmentcCr!)zi Augmented assignment of attributes is supported. We don't care about attr refs. z7 foo = None foo.bar += foo.baz Nr"r rrrtest_attrAugmentedAssignment/r$z!Test.test_attrAugmentedAssignmentcCr!)zP A 'global' can be declared in one scope and reused in another. zV def f(): global foo def g(): foo = 'anything'; foo.is_used() Nr"r rrr#test_globalDeclaredInDifferentScope9roz(Test.test_globalDeclaredInDifferentScopecCs,|d|d|d|ddS)z; Test to traverse ARG and ARGUMENT handler z1 def foo(a, b): pass z6 def foo(a, b, c=0): pass z= def foo(a, b, c=0, *args): pass zG def foo(a, b, c=0, *args, **kwargs): pass Nr"r rrrtest_function_argumentsBs   zTest.test_function_argumentscCr0)NzL def foo(a, b, c=0, *args, d=0, **kwargs): pass r"r rrrtest_function_arguments_python3Zr2z$Test.test_function_arguments_python3N)9__name__ __module__ __qualname__rrrrrrrr#r%r'r)r*r+r,r-r.r/r1r3r7r8r9r;r=r>rArBrFrGrHrIrKrLrNrOrPrRrbrfrrgrhrirjrkrlrmrnrprqrrrsrtrurrrrr sp                    &*-<JJ5G           rc@seZdZdZddZddZddZdd Zed d d Z d dZ ddZ ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Z d;d<Z!d=d>Z"d?d@Z#dAdBZ$dCdDZ%dEdFZ&dGdHZ'dIdJZ(dKdLZ)dMdNZ*dOdPZ+e,e-dQkdRdSdTZ.dUdVZ/dWdXZ0dYdZZ1d[d\Z2d]d^Z3d_d`Z4dadbZ5dcddZ6dedfZ7dgdhZ8didjZ9dkdlZ:dmdnZ;dodpZ 2: return x x = i * 2 Nr"r rrrtest_assignmentInsideLooproz.TestUnusedAssignment.test_assignmentInsideLoopcCsF|d|dtjtj|d|dtj|dtjdS)z Don't warn when a variable included in tuple unpacking is unused. It's very common for variables in a tuple unpacking assignment to be unused in good Python code, so warning will only create false positives. z6 def f(tup): (x, y) = tup z4 def f(): (x, y) = 1, 2 zq def f(): (x, y) = coords = 1, 2 if x > 1: print(coords) z= def f(): (x, y) = coords = 1, 2 z= def f(): coords = (x, y) = 1, 2 Nrr rrrtest_tupleUnpackings  z(TestUnusedAssignment.test_tupleUnpackingcCs |d|dtjtjdS)zR Don't warn when a variable included in list unpacking is unused. z6 def f(tup): [x, y] = tup z6 def f(): [x, y] = [1, 2] Nrr rrrtest_listUnpackings z'TestUnusedAssignment.test_listUnpackingcCr!)zN Don't warn when the assignment is used in an inner function. z~ def barMaker(): foo = 5 def bar(): return foo return bar Nr"r rrrtest_closedOver$roz$TestUnusedAssignment.test_closedOvercCr!)z Don't warn when the assignment is used in an inner function, even if that inner function itself is in an inner function. z def barMaker(): foo = 5 def bar(): def baz(): return foo return bar Nr"r rrrtest_doubleClosedOver0r$z*TestUnusedAssignment.test_doubleClosedOvercCr!)z} Do not warn about unused local variable __tracebackhide__, which is a special variable for py.test. zL def helper(): __tracebackhide__ = True Nr"r rrr!test_tracebackhideSpecialVariable>r$z6TestUnusedAssignment.test_tracebackhideSpecialVariablecCs*|d|dtj|dtjdS)z9 Test C{foo if bar else baz} statements. za = 'moo' if True else 'oink'za = foo if True else 'oink'za = 'moo' if True else barNr5r rrr test_ifexpHs zTestUnusedAssignment.test_ifexpcCs4|d|d|dtj|dtjdS)z/ Test C{if (foo,)} conditions. z if (): passzC if ( True ): pass zD if ( True, ): pass z? x = 1 if ( True, ) else 2 N)r r IfTupler rrr test_if_tuplePs  z"TestUnusedAssignment.test_if_tuplecCr!)z No warnings are emitted for using inside or after a nameless C{with} statement a name defined beforehand. zR bar = None with open("foo"): bar bar Nr"r rrrtest_withStatementNoNamesgr$z.TestUnusedAssignment.test_withStatementNoNamescCr!)z No warnings are emitted for using a name defined by a C{with} statement within the suite or afterwards. zF with open('foo') as bar: bar bar Nr"r rrrtest_withStatementSingleNamesr$z1TestUnusedAssignment.test_withStatementSingleNamecCr!)zn No warnings are emitted for using an attribute as the target of a C{with} statement. zR import foo with open('foo') as foo.bar: pass Nr"r rrrtest_withStatementAttributeName~r$z4TestUnusedAssignment.test_withStatementAttributeNamecCr!)zm No warnings are emitted for using a subscript as the target of a C{with} statement. zQ import foo with open('foo') as foo[0]: pass Nr"r rrrtest_withStatementSubscriptr$z0TestUnusedAssignment.test_withStatementSubscriptcCr)z An undefined name warning is emitted if the subscript used as the target of a C{with} statement is not defined. zS import foo with open('foo') as foo[bar]: pass Nr5r rrr$test_withStatementSubscriptUndefinedr(z9TestUnusedAssignment.test_withStatementSubscriptUndefinedcCr!)z No warnings are emitted for using any of the tuple of names defined by a C{with} statement within the suite or afterwards. zW with open('foo') as (bar, baz): bar, baz bar, baz Nr"r rrrtest_withStatementTupleNamesr$z1TestUnusedAssignment.test_withStatementTupleNamescCr!)z No warnings are emitted for using any of the list of names defined by a C{with} statement within the suite or afterwards. zW with open('foo') as [bar, baz]: bar, baz bar, baz Nr"r rrrtest_withStatementListNamesr$z0TestUnusedAssignment.test_withStatementListNamescCr!)aq If the target of a C{with} statement uses any or all of the valid forms for that part of the grammar (See U{http://docs.python.org/reference/compound_stmts.html#the-with-statement}), the names involved are checked both for definedness and any bindings created are respected in the suite of the statement and afterwards. z c = d = e = g = h = i = None with open('foo') as [(a, b), c[d], e.f, g[h:i]]: a, b, c, d, e, g, h, i a, b, c, d, e, g, h, i Nr"r rrr#test_withStatementComplicatedTargetrz8TestUnusedAssignment.test_withStatementComplicatedTargetcCr)z An undefined name warning is emitted if the name first defined by a C{with} statement is used before the C{with} statement. zG bar with open('foo') as bar: pass Nr5r rrr%test_withStatementSingleNameUndefinedr(z:TestUnusedAssignment.test_withStatementSingleNameUndefinedcCr)z An undefined name warning is emitted if a name first defined by the tuple-unpacking form of the C{with} statement is used before the C{with} statement. zN baz with open('foo') as (bar, baz): pass Nr5r rrr%test_withStatementTupleNamesUndefinedz:TestUnusedAssignment.test_withStatementTupleNamesUndefinedcCr)z A redefined name warning is emitted if a name bound by an import is rebound by the name defined by a C{with} statement. zN import bar with open('foo') as bar: pass Nrr rrr%test_withStatementSingleNameRedefinedr(z:TestUnusedAssignment.test_withStatementSingleNameRedefinedcCr)z A redefined name warning is emitted if a name bound by an import is rebound by one of the names defined by the tuple-unpacking form of a C{with} statement. zU import bar with open('foo') as (bar, baz): pass Nrr rrr%test_withStatementTupleNamesRedefinedrz:TestUnusedAssignment.test_withStatementTupleNamesRedefinedcCr)z An undefined name warning is emitted if a name is used inside the body of a C{with} statement without first being bound. z: with open('foo') as bar: baz Nr5r rrr!test_withStatementUndefinedInsiderz6TestUnusedAssignment.test_withStatementUndefinedInsidecCr!)z| A name defined in the body of a C{with} statement can be used after the body ends without warning. zK with open('foo') as bar: baz = 10 baz Nr"r rrr#test_withStatementNameDefinedInBodyr$z8TestUnusedAssignment.test_withStatementNameDefinedInBodycCs |dtj|dtjdS)z An undefined name warning is emitted if a name in the I{test} expression of a C{with} statement is undefined. z3 with bar as baz: pass z3 with bar as bar: pass Nr5r rrr'test_withStatementUndefinedInExpressions z assert (False, 'x') assert (False, ) N)r r AssertTupler rrrtest_assert_tuple{sz&TestUnusedAssignment.test_assert_tuplecCr!)z,An assert of an empty tuple is always False.z assert () Nr"r rrrtest_assert_tuple_emptyr4z,TestUnusedAssignment.test_assert_tuple_emptycCr!)z,An assert of a static value is not an error.z. assert True assert 1 Nr"r rrrtest_assert_staticr4z'TestUnusedAssignment.test_assert_staticcCr)z. Test C{yield from} statement z9 def bar(): yield from foo() Nr5r rrrtest_yieldFromUndefinedr&z,TestUnusedAssignment.test_yieldFromUndefinedcCr!)z.Test PEP 498 f-strings are treated as a usage.z3 baz = 0 print(f'{4*baz}') Nr"r rrr test_f_stringr4z"TestUnusedAssignment.test_f_stringcCr!)zATest PEP 572 assignment expressions are treated as usage / write.zJ from foo import y print(x := y) print(x) Nr"r rrrtest_assign_exprr4z%TestUnusedAssignment.test_assign_exprcCr!)z5Test assignment expressions in generator expressions.zO if (any((y := x[0]) for x in [[True]])): print(y) Nr"r rrr test_assign_expr_generator_scoper4z5TestUnusedAssignment.test_assign_expr_generator_scopecCr!)z2Test assignment expressions in nested expressions.zz if ([(y:=x) for x in range(4) if [(z:=q) for q in range(4)]]): print(y) print(z) Nr"r rrrtest_assign_expr_nestedr4z,TestUnusedAssignment.test_assign_expr_nestedN)=rvrwrx__doc__rzr{r|r}rr~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrryast                                    ryc@s,eZdZddZddZddZddZd S) TestStringFormattingcCsZ|dtj|dtj|dtj|dtj|d|d|ddS)Nzf'foo'z= f"""foo bar """ zX print( f'foo' f'bar' ) zf'{{}}'z5 x = 5 print(f'{x}') z? x = 'a' * 90 print(f'{x:.8}') zC x = y = 5 print(f'{x:>2} {y:>2}') )r r FStringMissingPlaceholdersr rrr"test_f_string_without_placeholderss  z7TestStringFormatting.test_f_string_without_placeholderscCs|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|d tj|d |d |d |d |d|d|ddS)Nz# '{'.format(1) z+ '{} {1}'.format(1, 2) z+ '{0} {}'.format(1, 2) z' '{}'.format(1, 2) z+ '{}'.format(1, bar=2) z' '{} {}'.format(1) z$ '{2}'.format() z& '{bar}'.format() z0 '{:{:{}}}'.format(1, 2, 3) z'{.__class__}'.format('')z('{foo[bar]}'.format(foo={'bar': 'barv'})z8 print('{:{}} {}'.format(1, 15, 2)) z- print('{:2}'.format(1)) z1 '{foo}-{}'.format(1, foo=2) z8 a = () "{}".format(*a) z< k = {} "{foo}".format(**k) )r r StringDotFormatInvalidFormatStringDotFormatMixingAutomatic'StringDotFormatExtraPositionalArguments"StringDotFormatExtraNamedArgumentsStringDotFormatMissingArgumentr rrrtest_invalid_dot_format_callssD      z2TestStringFormatting.test_invalid_dot_format_callscCs|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|d tj|d tj |d tj |d |d |d|ddS)Nz/ '%(foo)' % {'foo': 'bar'} z3 '%s %(foo)s' % {'foo': 'bar'} z3 '%(foo)s %s' % {'foo': 'bar'} z! '%j' % (1,) z$ '%s %s' % (1,) z) '%s %s' % (1, 2, 3) z$ '%(bar)s' % {} z6 '%(bar)s' % {'bar': 1, 'baz': 2} z+ '%(bar)s' % (1, 2, 3) z* '%s %s' % {'k': 'v'} z1 '%(bar)*s' % {'bar': 'baz'} z: '%s' % {'foo': 'bar', 'baz': 'womp'} z+ "%1000000000000f" % 1 z, '%% %s %% %s' % (1, 2) zO '%.*f' % (2, 1.1234) '%*.*f' % (5, 2, 3.1234) ) r r PercentFormatInvalidFormat$PercentFormatMixedPositionalAndNamed'PercentFormatUnsupportedFormatCharacter$PercentFormatPositionalCountMismatchPercentFormatMissingArgument PercentFormatExtraNamedArgumentsPercentFormatExpectedMappingPercentFormatExpectedSequence!PercentFormatStarRequiresSequencer rrr!test_invalid_percent_format_callssJ   z6TestStringFormatting.test_invalid_percent_format_callscCr)NzS a = [] '%s %s' % [*a] '%s %s' % (*a,) z8 k = {} '%(k)s' % {**k} r"r rrr5test_ok_percent_format_cannot_determine_element_countBrzJTestStringFormatting.test_ok_percent_format_cannot_determine_element_countN)rvrwrxrrrrrrrrrs 6 4rc@sleZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZdS)TestAsyncStatementscCr0)Nz8 async def bar(): return 42 r"r rrr test_asyncDefPr2z!TestAsyncStatements.test_asyncDefcCr0)NzS async def read_data(db): await db.fetch('SELECT ...') r"r rrrtest_asyncDefAwaitVr2z&TestAsyncStatements.test_asyncDefAwaitcCr)Nz; async def bar(): return foo() r5r rrrtest_asyncDefUndefined\r z*TestAsyncStatements.test_asyncDefUndefinedcCr0)Nz async def read_data(db): output = [] async for row in db.cursor(): output.append(row) return output r"r rrr test_asyncForbr2z!TestAsyncStatements.test_asyncForcCr0)NzY async def coro(it): async for _ in it: pass r"r rrrtest_asyncForUnderscoreLoopVarkr2z2TestAsyncStatements.test_asyncForUnderscoreLoopVarcCr)Nz async def read_data(db): output = [] async for row in db.cursor(): if row[0] == 'skip': continue output.append(row) return output z async def read_data(db): output = [] async for row in db.cursor(): if row[0] == 'stop': break output.append(row) return output r"r rrrtest_loopControlInAsyncForrs  z.TestAsyncStatements.test_loopControlInAsyncForcCs |dtj|dtjdS)Nz async def read_data(db): output = [] async for row in db.cursor(): output.append(row) else: continue return output z async def read_data(db): output = [] async for row in db.cursor(): output.append(row) else: break return output )r r rJrMr rrrtest_loopControlInAsyncForElses  z2TestAsyncStatements.test_loopControlInAsyncForElsecCr0)Nz async def commit(session, data): async with session.transaction(): await session.update(data) r"r rrrtest_asyncWithr2z"TestAsyncStatements.test_asyncWithcCr0)Nz async def commit(session, data): async with session.transaction() as trans: await trans.begin() ... await trans.end() r"r rrrtest_asyncWithItemr2z&TestAsyncStatements.test_asyncWithItemcCr0)Nz9 def foo(a, b): return a @ b r"r rrr test_matmulr2zTestAsyncStatements.test_matmulcCr0)NzE hi = 'hi' mom = 'mom' f'{hi} {mom}' r"r rrrtest_formatstringr2z%TestAsyncStatements.test_formatstringcCs4|d|d|dtj|dtjdS)Nz; raise NotImplementedError("This is fine") z+ raise NotImplementedError z? raise NotImplemented("This isn't gonna work") z& raise NotImplemented )r r RaiseNotImplementedr rrrtest_raise_notimplementeds  z-TestAsyncStatements.test_raise_notimplementedN)rvrwrxrrrrrrrrrrrrrrrrrNs   rc@sHeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)TestIncompatiblePrintOperatorz@ Tests for warning about invalid use of print function. cCr0)Nz print("Hello") r"r rrrtest_valid_printr2z.TestIncompatiblePrintOperator.test_valid_printcCs4|dtjjd}||jd||jddS)Nzn from __future__ import print_function import sys print >>sys.stderr, "Hello" r)r r InvalidPrintSyntaxr assertEquallinenocol)r excrrr,test_invalid_print_when_imported_from_futureszJTestIncompatiblePrintOperator.test_invalid_print_when_imported_from_futurecCr0)Nz print += 1r"r rrrtest_print_augmented_assignr4z9TestIncompatiblePrintOperator.test_print_augmented_assigncCr!)zJ A valid assignment, tested for catching false positives. z` from __future__ import print_function log = print log("Hello") Nr"r rrrtest_print_function_assignmentrozs,  ^Z}