jSrSSKJr SSKJr SSKJrJrJ r "SS\5r "SS\5r "S S \5r "S S \5r "S S\5rg)z& Tests for various Pyflakes behavior. ) version_info)messages)TestCaseskipskipIfc\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!S r"S!r#S"r$S#r%S$r&S%r'S&r(S'r)S(r*\+"S)5S*5r,S+r-S,r.S-r/S.r0S/r1S0r2S1r3S2r4S3r5S4r6S5r7S6r8S7r9S8r:S9r;S:rS=r?S>r@g?)@Test cDURS[R5 g)Nzdef fu(bar, bar): pass)flakesmDuplicateArgumentselfs P/var/www/html/KUNJ/venv/lib/python3.13/site-packages/pyflakes/test/test_other.pytest_duplicateArgsTest.test_duplicateArgs s ,a.A.ABcbURS[R[R5 g)NzG a = 1 def f(): a; a=1 f() )r r UndefinedLocalUnusedVariablers r$test_localReferencedBeforeAssignment)Test.test_localReferencedBeforeAssignments&    q//  1rcURS5 URS5 URS[R5 URS5 URS5 g)zG 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 rrs rtest_redefinedInGeneratorTest.test_redefinedInGeneratorl                 rcURS5 URS5 URS[R5 URS5 URS5 g)zO 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)]} Nrrs r test_redefinedInSetComprehension%Test.test_redefinedInSetComprehension5rrcURS5 URS5 URS[R5 URS5 URS5 g)zP 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)]} Nrrs r!test_redefinedInDictComprehension&Test.test_redefinedInDictComprehensionRrrcDURS[R5 g)zN Test that shadowing a function definition with another one raises a warning. z5 def a(): pass def a(): pass Nr r RedefinedWhileUnusedrs rtest_redefinedFunctionTest.test_redefinedFunctionos   # # %rcDURS[R5 g)Nz- x = 1 def x(): pass r&rs r(test_redefined_function_shadows_variable-Test.test_redefined_function_shadows_variableys   # # %rc&URS5 g)zY Test that shadowing a function definition named with underscore doesn't raise anything. z5 def _(): pass def _(): pass Nr rs r test_redefinedUnderscoreFunction%Test.test_redefinedUnderscoreFunction   rcDURS[R5 g)zA Test that shadowing an underscore importation raises a warning. z; from .i18n import _ def _(): pass Nr&rs r#test_redefinedUnderscoreImportation(Test.test_redefinedUnderscoreImportation    # # %rcDURS[R5 g)z_ 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 Nr&rs rtest_redefinedClassFunction Test.test_redefinedClassFunction   # #  %rc&URS5 g)zc 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.rs rtest_redefinedIfElseFunction!Test.test_redefinedIfElseFunction   rcDURS[R5 g)zP Test that shadowing a function definition within an if block raises a warning. zN if True: def a(): pass def a(): pass Nr&rs rtest_redefinedIfFunctionTest.test_redefinedIfFunctionr9rc&URS5 g)zc 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.rs rtest_redefinedTryExceptFunction$Test.test_redefinedTryExceptFunctionr=rcDURS[R5 g)zP Test that shadowing a function definition within a try block raises a warning. zk try: def a(): pass def a(): pass except: pass Nr&rs rtest_redefinedTryFunctionTest.test_redefinedTryFunctions   # #  %rc&URS5 g)zj 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.rs rtest_redefinedIfElseInListComp#Test.test_redefinedIfElseInListCompr=rc&URS5 g)zo 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.rs rtest_functionDecoratorTest.test_functionDecoratorr=rc&URS5 g)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.rs rtest_classFunctionDecorator Test.test_classFunctionDecorator   rc&URS5 g)Nz class A: @property def t(self): pass @t.setter def t(self, value): pass @t.deleter def t(self): pass r.rs rtest_modernPropertyTest.test_modernPropertys  rc&URS5 g)zDon't die on unary +.z+1Nr.rs rtest_unaryPlusTest.test_unaryPluss DrcDURS[R5 g)zV If a name in the base list of a class definition is undefined, a warning is emitted. z2 class foo(foo): pass Nr r UndefinedNamers rtest_undefinedBaseClassTest.test_undefinedBaseClass  __ rcDURS[R5 g)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 NrXrs r"test_classNameUndefinedInClassBody'Test.test_classNameUndefinedInClassBody r\rc&URS5 g)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.rs rtest_classNameDefinedPreviously$Test.test_classNameDefinedPreviouslys   rcDURS[R5 g)zG If a class is defined twice in the same module, a warning is emitted. zQ class Foo: pass class Foo: pass Nr&rs rtest_classRedefinitionTest.test_classRedefinition"    # #  %rcDURS[R5 g)z> If a function is redefined as a class, a warning is emitted. zQ def Foo(): pass class Foo: pass Nr&rs rtest_functionRedefinedAsClass"Test.test_functionRedefinedAsClass-rfrcDURS[R5 g)z> If a class is redefined as a function, a warning is emitted. zQ class Foo: pass def Foo(): pass Nr&rs rtest_classRedefinedAsFunction"Test.test_classRedefinedAsFunction8rfrcDURS[R5 g)z; If a return is used inside a class, a warning is emitted. z7 class Foo(object): return Nr r ReturnOutsideFunctionrs rtest_classWithReturnTest.test_classWithReturnCs    $ $ &rcDURS[R5 g)z@ If a return is used at the module level, a warning is emitted. z return Nrnrs rtest_moduleWithReturnTest.test_moduleWithReturnLs   $ $ &rcDURS[R5 g)z: If a yield is used inside a class, a warning is emitted. z6 class Foo(object): yield Nr r YieldOutsideFunctionrs rtest_classWithYieldTest.test_classWithYieldTr5rcDURS[R5 g)z? If a yield is used at the module level, a warning is emitted. z yield Nrvrs rtest_moduleWithYieldTest.test_moduleWithYield]   # # %rcDURS[R5 g)z? If a yield from is used inside a class, a warning is emitted. zE class Foo(object): yield from range(10) Nrvrs rtest_classWithYieldFromTest.test_classWithYieldFromer5rcDURS[R5 g)zD If a yield from is used at the module level, a warning is emitted. z& yield from range(10) Nrvrs rtest_moduleWithYieldFromTest.test_moduleWithYieldFromnr}rcURS[R5 URS[R5 URS[R5 URS[R5 URS[R5 URS[R5 g)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 ContinueOutsideLooprs rtest_continueOutsideLoopTest.test_continueOutsideLoopvs   " " $   " " $   " "  $   " " $   " "  $   " "  $rcURS5 URS5 URS5 URS5 URS5 URS5 g)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.rs rtest_continueInsideLoopTest.test_continueInsideLoopsr              rcURS[R5 URS[R5 URS[R5 URS[R5 URS[R5 URS[R5 URS[R5 g)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 BreakOutsideLooprs rtest_breakOutsideLoopTest.test_breakOutsideLoops     !     !      !     !      !      !      !rcURS5 URS5 URS5 URS5 URS5 URS5 URS5 URS5 g) 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.rs rtest_breakInsideLoopTest.test_breakInsideLoops                    rcURS5 URS5 URS5 URS5 URS5 URS5 g)z 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.rs rtest_defaultExceptLastTest.test_defaultExceptLast/st,                 rc|URS[R5 URS[R5 URS[R5 URS[R[R5 URS[R5 URS[R5 URS[R5 URS[R[R5 URS [R5 URS [R5 URS [R5 URS [R[R5 URS [R5 URS[R5 URS[R5 URS[R[R5 g)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 DefaultExceptNotLastrs rtest_defaultExceptNotLastTest.test_defaultExceptNotLastys   # # %   # # %   # # %   # #Q%;%; =   # # %   # # %   # # %   # #Q%;%; =   # # %   # # %   # # %   # #Q%;%; =   # # %   # # %   # # %   # #Q%;%; =rcURS5 URS5 URS5 URS5 URS5 URS5 URS5 URS5 URS 5 S RS [S 555S -nURU5 SS RS[S 555-S-nURU5 SS RS[S 555-S-nURU5 g)z& 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) , c3,# UH nSU-v M g7fza%dN.0is r 5Test.test_starredAssignmentNoError..k;):Aeai):z, *rest = range(1<<8)(c3,# UH nSU-v M g7frrrs rrroA/@!EAI/@rz, *rest) = range(1<<8)[c3,# UH nSU-v M g7frrrs rrrsrrz, *rest] = range(1<<8)N)r joinrangerss rtest_starredAssignmentNoError"Test.test_starredAssignmentNoErrorBs=                           II;z):; ; # $ A $))AuZ/@AA A $ % A $))AuZ/@AA A $ % ArcSRS[S555S-nURU[R5 SSRS[S555-S-nURU[R5 SSRS [S555-S -nURU[R5 SRS [S 555S -nURU[R5 SSRS[S 555-S-nURU[R5 SSRS[S 555-S-nURU[R5 URS[R 5 URS[R 5 URS[R 5 URS[R 5 URS[R 5 URS[R 5 URS[R 5 URS[R 5 URS[R 5 g)zX SyntaxErrors (not encoded in the ast) surrounding Python 3 extended iterable unpacking rc3,# UH nSU-v M g7frrrs rr4Test.test_starredAssignmentErrors..}s7Aeairz, *rest = range(1<<8 + 1)rc3,# UH nSU-v M g7frrrs rrr=}!EAI}rz, *rest) = range(1<<8 + 1)rc3,# UH nSU-v M g7frrrs rrrrrz, *rest] = range(1<<8 + 1)c3,# UH nSU-v M g7frrrs rrrrriz, *rest = range(1<<8 + 2)c3,# UH nSU-v M g7frrrs rrrrrz, *rest) = range(1<<8 + 2)c3,# UH nSU-v M g7frrrs rrrrrz, *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)rrr r %TooManyExpressionsInStarredAssignmentTwoStarredExpressionsrs rtest_starredAssignmentErrors!Test.test_starredAssignmentErrorswsO II7v7 7 ' ( Aq>>? $))=uV}== = ( ) Aq>>? $))=uV}== = ( ) Aq>>? II;z):; ; ' ( Aq>>? $))AuZ/@AA A ( ) Aq>>? $))AuZ/@AA A ( ) Aq>>?   $ $ &   $ $ &   $ $ &   $ $ &   $ $ &   $ $ &   $ $ &   $ $ &   $ $ &rz= y x > y Nr.rs rtest_comparisonTest.test_comparisons  rc&URS5 g)zV 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.rs r test_identityTest.test_identityr=rc&URS5 g)zX 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.rs rtest_containmentTest.test_containmentr=rcHURS5 URS5 g)z. break and continue statements are supported. z4 for x in [1, 2]: break z7 for x in [1, 2]: continue Nr.rs rtest_loopControlTest.test_loopControls(      rc&URS5 g)z# Ellipsis in a slice is supported. z [1, 2][...] Nr.rs r test_ellipsisTest.test_ellipsis   rc&URS5 g)z Extended slices are supported. z+ x = 3 [1, 2][x,:] Nr.rs rtest_extendedSliceTest.test_extendedSlice   rc&URS5 g)zP Augmented assignment of a variable is supported. We don't care about var refs. z* foo = 0 foo += 1 Nr.rs rtest_varAugmentedAssignment Test.test_varAugmentedAssignment%r1rc&URS5 g)zQ Augmented assignment of attributes is supported. We don't care about attr refs. z7 foo = None foo.bar += foo.baz Nr.rs rtest_attrAugmentedAssignment!Test.test_attrAugmentedAssignment/r1rcDURS[R5 g)z@ 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 UnusedIndirectAssignmentrs r#test_globalDeclaredInDifferentScope(Test.test_globalDeclaredInDifferentScope9s    ' ' )rcDURS[R5 g)Nz g = 0 def f1(): global g g = 1 def f2(): global g # this is unused! return g rrs rtest_unused_global_statement!Test.test_unused_global_statementBs   ' ' )rcDURS[R5 g)Nz def f(): x = 1 def set_x(): nonlocal x x = 2 def get_x(): nonlocal x return x set_x() return get_x() rrs rtest_unused_nonlocal_statement#Test.test_unused_nonlocal_statementMs   ' ' )rcbURS[R[R5 g)Nzi g = 0 def f(): global g def f2(): g = 2 )r r rrrs r?test_unused_global_statement_not_marked_as_used_by_nested_scopeDTest.test_unused_global_statement_not_marked_as_used_by_nested_scope[s&   ' ')9)9  ;rc&URS5 g)Nz g = 0 class C: global g g = 1 def f(): nl = 0 class C: nonlocal nl nl = 1 r.rs r$test_global_nonlocal_in_class_bodies)Test.test_global_nonlocal_in_class_bodiesds  rcDURS[R5 g)NzO g = 0 class C: global g u = g rrs rtest_unused_global_in_class Test.test_unused_global_in_classqs   ' '  )rcDURS[R5 g)Nzu def f(): nl = 1 class C: nonlocal nl u = nl rrs rtest_unused_nonlocal_in_clas!Test.test_unused_nonlocal_in_clasys   ' '  )rcURS5 URS5 URS5 URS5 g)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.rs rtest_function_argumentsTest.test_function_argumentssN         rc&URS5 g)NzL def foo(a, b, c=0, *args, d=0, **kwargs): pass r.rs rtest_function_arguments_python3$Test.test_function_arguments_python3   rrN)A__name__ __module__ __qualname____firstlineno__rrrr r#r(r+r/r3r7r;r?rBrErHrKrNrRrUrZr^rardrhrkrprsrxr{rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr__static_attributes__rrrr r sKC1 : : :%%  % %   %   %           % % %&&%%%%$$L( T+!Z: xH TG=R3jE&N HI%J%              ) ) );  )) 0 rr c\rSrSrSrSrSrSrSr\ "S5S5r S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!S r"S!r#S"r$S#r%S$r&S%r'S&r(S'r)S(r*S)r+S*r,S+r-\."\/S,:S-5S.5r0S/r1S0r2S1r3S2r4S3r5S4r6S5r7S6r8S7r9S8r:S9r;\."\/S::S;5S<5rr>S?r?S@r@SArASBrBgC)DTestUnusedAssignmentiz- Tests for warning about unused assignments. cDURS[R5 g)zK Warn when a variable in a function is assigned a value that's never used. z, def a(): b = 1 Nrrs rtest_unusedVariable(TestUnusedAssignment.test_unusedVariables     rc&URS5 g)zP Don't warn when the magic "_" (underscore) variable is unused. See issue #202. zC def a(unused_param): _ = unused_param Nr.rs rtest_unusedUnderscoreVariable2TestUnusedAssignment.test_unusedUnderscoreVariabler1rc&URS5 g)z? Using locals() it is perfectly valid to have unused variables zH def a(): b = 1 return locals() Nr.rs rtest_unusedVariableAsLocals0TestUnusedAssignment.test_unusedVariableAsLocals   rcDURS[R5 g)z1 Using locals() in wrong scope should not matter zq def a(): locals() def a(): b = 1 return Nrrs rtest_unusedVariableNoLocals0TestUnusedAssignment.test_unusedVariableNoLocalss       rzAtodo: Difficult because it doesn't apply in the context of a loopcDURS[R5 g)zF Shadowing a used variable can still raise an UnusedVariable warning. zR def a(): b = 1 b.foo() b = 2 Nrrs rtest_unusedReassignedVariable2TestUnusedAssignment.test_unusedReassignedVariables      rc&URS5 g)z\ Shadowing a used variable cannot raise an UnusedVariable warning in the context of a loop. z^ def a(): b = True while b: b = False Nr.rs rtest_variableUsedInLoop,TestUnusedAssignment.test_variableUsedInLoopr=rc&URS5 g)z Assigning to a global and then not using that global is perfectly acceptable. Do not mistake it for an unused local variable. zO b = 0 def a(): global b b = 1 Nr.rs rtest_assignToGlobal(TestUnusedAssignment.test_assignToGlobalr=rc&URS5 g)z Assigning to a nonlocal and then not using that binding is perfectly acceptable. Do not mistake it for an unused local variable. zW b = b'0' def a(): nonlocal b b = b'1' Nr.rs rtest_assignToNonlocal*TestUnusedAssignment.test_assignToNonlocalr=rc&URS5 g)z Assigning to a member of another object and then not using that member variable is perfectly acceptable. Do not mistake it for an unused local variable. zR class b: pass def a(): b.foo = 1 Nr.rs rtest_assignToMember(TestUnusedAssignment.test_assignToMember   rc&URS5 g)zG Don't warn when a variable in a for loop is assigned to but not used. zO def f(): for i in range(10): pass Nr.rs rtest_assignInForLoop)TestUnusedAssignment.test_assignInForLooprrc&URS5 g)zQ Don't warn when a variable in a list comprehension is assigned to but not used. z@ def f(): [None for i in range(10)] Nr.rs rtest_assignInListComprehension3TestUnusedAssignment.test_assignInListComprehensionr1rc&URS5 g)zS Don't warn when a variable in a generator expression is assigned to but not used. z@ def f(): (None for i in range(10)) Nr.rs rtest_generatorExpression-TestUnusedAssignment.test_generatorExpression#r1rc&URS5 g)zG Don't warn when a variable assignment occurs lexically after its use. z def f(): x = None for i in range(10): if i > 2: return x x = i * 2 Nr.rs rtest_assignmentInsideLoop.TestUnusedAssignment.test_assignmentInsideLoop-s   rc&URS5 URS[R[R5 URS5 URS[R5 URS[R5 g)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 Nrrs rtest_tupleUnpacking(TestUnusedAssignment.test_tupleUnpacking:s       q// 1            rcURS5 URS[R[R5 g)zB 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] Nrrs rtest_listUnpacking'TestUnusedAssignment.test_listUnpackingWs;       q// 1rc&URS5 g)z> Don't warn when the assignment is used in an inner function. z~ def barMaker(): foo = 5 def bar(): return foo return bar Nr.rs rtest_closedOver$TestUnusedAssignment.test_closedOverds   rc&URS5 g)zz 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.rs rtest_doubleClosedOver*TestUnusedAssignment.test_doubleClosedOverps   rc&URS5 g)ze Do not warn about unused local variable __tracebackhide__, which is a special variable for py.test. zL def helper(): __tracebackhide__ = True Nr.rs r!test_tracebackhideSpecialVariable6TestUnusedAssignment.test_tracebackhideSpecialVariable~r1rc&URS5 g)zd Do not warn about unused local variable __debuggerskip__, which is a special variable for IPython. zK def helper(): __debuggerskip__ = True Nr.rs r test_debuggerskipSpecialVariable5TestUnusedAssignment.test_debuggerskipSpecialVariabler1rcURS5 URS[R5 URS[R5 g)z) 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 barNrXrs r test_ifexpTestUnusedAssignment.test_ifexps7 34 11??C 0!//BrcURS5 URS5 URS[R5 URS[R5 g)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 IfTuplers r test_if_tuple"TestUnusedAssignment.test_if_tuplesZ %&    YY    YY  rc&URS5 g)zk 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.rs rtest_withStatementNoNames.TestUnusedAssignment.test_withStatementNoNamesr=rc&URS5 g)zi 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.rs rtest_withStatementSingleName1TestUnusedAssignment.test_withStatementSingleNamerPrc&URS5 g)zV 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.rs rtest_withStatementAttributeName4TestUnusedAssignment.test_withStatementAttributeNamerPrc&URS5 g)zU 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.rs rtest_withStatementSubscript0TestUnusedAssignment.test_withStatementSubscriptrPrcDURS[R5 g)zq 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 NrXrs r$test_withStatementSubscriptUndefined9TestUnusedAssignment.test_withStatementSubscriptUndefined  __  rc&URS5 g)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.rs rtest_withStatementTupleNames1TestUnusedAssignment.test_withStatementTupleNamesrPrc&URS5 g)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.rs rtest_withStatementListNames0TestUnusedAssignment.test_withStatementListNamesrPrc&URS5 g)aA 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.rs r#test_withStatementComplicatedTarget8TestUnusedAssignment.test_withStatementComplicatedTargetr#rcDURS[R5 g)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 NrXrs r%test_withStatementSingleNameUndefined:TestUnusedAssignment.test_withStatementSingleNameUndefinedrXrcDURS[R5 g)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 NrXrs r%test_withStatementTupleNamesUndefined:TestUnusedAssignment.test_withStatementTupleNamesUndefineds  __  rcDURS[R5 g)zy 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 Nr&rs r%test_withStatementSingleNameRedefined:TestUnusedAssignment.test_withStatementSingleNameRedefined%r9rcDURS[R5 g)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 Nr&rs r%test_withStatementTupleNamesRedefined:TestUnusedAssignment.test_withStatementTupleNamesRedefined0s   # #  %rcDURS[R5 g)zz 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 NrXrs r!test_withStatementUndefinedInside6TestUnusedAssignment.test_withStatementUndefinedInside<r\rc&URS5 g)zd 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.rs r#test_withStatementNameDefinedInBody8TestUnusedAssignment.test_withStatementNameDefinedInBodyFrPrcURS[R5 URS[R5 g)zo 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 NrXrs r'test_withStatementUndefinedInExpression assert (False, 'x') assert (False, ) N)r r AssertTuplers rtest_assert_tuple&TestUnusedAssignment.test_assert_tuples"  ]]AMM +rc&URS5 g)z,An assert of an empty tuple is always False.z assert () Nr.rs rtest_assert_tuple_empty,TestUnusedAssignment.test_assert_tuple_emptys   rc&URS5 g)z,An assert of a static value is not an error.z. assert True assert 1 Nr.rs rtest_assert_static'TestUnusedAssignment.test_assert_staticrrcDURS[R5 g)z Test C{yield from} statement z9 def bar(): yield from foo() NrXrs rtest_yieldFromUndefined,TestUnusedAssignment.test_yieldFromUndefineds  __ rc&URS5 g)z.Test PEP 498 f-strings are treated as a usage.z3 baz = 0 print(f'{4*baz}') Nr.rs r test_f_string"TestUnusedAssignment.test_f_stringrrrnew in Python 3.14c&URS5 g)Nz? baz = 0 tmpl = t'hello {baz}' r.rs r test_t_string"TestUnusedAssignment.test_t_stringrrc&URS5 g)zATest PEP 572 assignment expressions are treated as usage / write.zJ from foo import y print(x := y) print(x) Nr.rs rtest_assign_expr%TestUnusedAssignment.test_assign_expr   rc&URS5 g)Nz? a: int print(a := 3) print(a) r.rs r!test_assign_expr_after_annotation6TestUnusedAssignment.test_assign_expr_after_annotation   rc&URS5 g)z5Test assignment expressions in generator expressions.zO if (any((y := x[0]) for x in [[True]])): print(y) Nr.rs r test_assign_expr_generator_scope5TestUnusedAssignment.test_assign_expr_generator_scoperrc&URS5 g)Nz def foo(x): fns = [lambda x: x + 1, lambda x: x + 2, lambda x: x + 3] return [(x := fn(x)) for fn in fns] r.rs r4test_assign_expr_generator_scope_reassigns_parameterITestUnusedAssignment.test_assign_expr_generator_scope_reassigns_parameterrrc&URS5 g)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.rs rtest_assign_expr_nested,TestUnusedAssignment.test_assign_expr_nested rrrN)Crrrr__doc__rr rrrrrrrr!r%r(r+r.r1r4r7r:r=r@rCrGrJrMrPrSrVrZr]r`rcrfrirlrorrrurxr{r~rrrrrrrrrrrrrrrrrrrrrrrrrrrsx    MN O              : 1      C.                  % %         L7 "$89:        +    L7 "$89 :      rrcP\rSrSrSr\"\S:S5S5rSrSr Sr S r g ) TestStringFormattingicjURS[R5 URS[R5 URS[R5 URS[R5 URS5 URS5 URS5 g)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 FStringMissingPlaceholdersrs r"test_f_string_without_placeholders7TestStringFormatting.test_f_string_without_placeholderss Ha::;   ) )  +   ) )  + Iq;;<       rrrcfURS[R5 URS5 g)Nzt'foo'z> x = y = 5 tmpl = t'{x:0{y}}' )r r TStringMissingPlaceholdersrs r"test_t_string_missing_placeholders7TestStringFormatting.test_t_string_missing_placeholders7s' Ha::;   rc2URS[R5 URS[R5 URS[R5 URS[R5 URS[R 5 URS[R 5 URS[R 5 URS[R 5 URS [R5 URS 5 URS 5 URS 5 URS 5 URS5 URS5 URS5 g)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"StringDotFormatExtraNamedArgumentsStringDotFormatMissingArgumentrs rtest_invalid_dot_format_calls2TestStringFormatting.test_invalid_dot_format_calls@su   + + -   - - /   - - /   6 6 8   1 1 3   - - /   - - /   - - /   + + - /0 >?               rcLURS[R5 URS[R5 URS[R5 URS[R5 URS[R 5 URS[R 5 URS[R 5 URS[R5 URS [R5 URS [R5 URS [R5 URS 5 URS 5 URS5 URS5 g)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!PercentFormatStarRequiresSequencers r!test_invalid_percent_format_calls6TestStringFormatting.test_invalid_percent_format_callsvs   ) ) +   3 3 5   3 3 5   6 6 8   3 3 5   3 3 5   + + .   / / 1   + + -   , , .   0 0 2            rcHURS5 URS5 g)NzS a = [] '%s %s' % [*a] '%s %s' % (*a,) z8 k = {} '%(k)s' % {**k} r.rs r5test_ok_percent_format_cannot_determine_element_countJTestStringFormatting.test_ok_percent_format_cannot_determine_element_counts&     rrN) rrrrrrrrrrrrrrrrrs9 > L7 "$89 : 4 l2 h  rrc\\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrg)TestAsyncStatementsic&URS5 g)Nz8 async def bar(): return 42 r.rs r test_asyncDef!TestAsyncStatements.test_asyncDefrrc&URS5 g)NzS async def read_data(db): await db.fetch('SELECT ...') r.rs rtest_asyncDefAwait&TestAsyncStatements.test_asyncDefAwaitrrcDURS[R5 g)Nz; async def bar(): return foo() rXrs rtest_asyncDefUndefined*TestAsyncStatements.test_asyncDefUndefineds  __ rc&URS5 g)Nz async def read_data(db): output = [] async for row in db.cursor(): output.append(row) return output r.rs r test_asyncFor!TestAsyncStatements.test_asyncFor   rc&URS5 g)NzY async def coro(it): async for _ in it: pass r.rs rtest_asyncForUnderscoreLoopVar2TestAsyncStatements.test_asyncForUnderscoreLoopVarrrcHURS5 URS5 g)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.rs rtest_loopControlInAsyncFor.TestAsyncStatements.test_loopControlInAsyncFors&      rcURS[R5 URS[R5 g)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 rrrs rtest_loopControlInAsyncForElse2TestAsyncStatements.test_loopControlInAsyncForElses<   " " $     !rc&URS5 g)Nz async def commit(session, data): async with session.transaction(): await session.update(data) r.rs rtest_asyncWith"TestAsyncStatements.test_asyncWithrrc&URS5 g)Nz async def commit(session, data): async with session.transaction() as trans: await trans.begin() ... await trans.end() r.rs rtest_asyncWithItem&TestAsyncStatements.test_asyncWithItem rrc&URS5 g)Nz9 def foo(a, b): return a @ b r.rs r test_matmulTestAsyncStatements.test_matmulrrc&URS5 g)NzE hi = 'hi' mom = 'mom' f'{hi} {mom}' r.rs rtest_formatstring%TestAsyncStatements.test_formatstringrrcURS5 URS5 URS[R5 URS[R5 g)Nz; raise NotImplementedError("This is fine") z+ raise NotImplementedError z? raise NotImplemented("This isn't gonna work") z& raise NotImplemented )r r RaiseNotImplementedrs rtest_raise_notimplemented-TestAsyncStatements.test_raise_notimplemented!s^         " " $   " " $rrN)rrrrrrrrrrrrrrrr rrrrrrs>      *!*    $rrcB\rSrSrSrSrSrSrSrSr Sr S r S r g ) TestIncompatiblePrintOperatori3z8 Tests for warning about invalid use of print function. c&URS5 g)Nz print("Hello") r.rs rtest_valid_print.TestIncompatiblePrintOperator.test_valid_print8s   rcURS[R5RSnUR UR S5 UR UR S5 g)Nzn from __future__ import print_function import sys print >>sys.stderr, "Hello" r)r r InvalidPrintSyntaxr assertEquallinenocol)rexcs r,test_invalid_print_when_imported_from_futureJTestIncompatiblePrintOperator.test_invalid_print_when_imported_from_future=sXkk  ! ! #$,8A / Q' !$rc&URS5 g)Nz print += 1r.rs rtest_print_augmented_assign9TestIncompatiblePrintOperator.test_print_augmented_assignGs L!rc&URS5 g)z: A valid assignment, tested for catching false positives. z` from __future__ import print_function log = print log("Hello") Nr.rs rtest_print_function_assignmentr+s`"88S 8S l$r  8r  j] 8] @z$(z$z3 H3 r