j[XSSKrSSKJrJr SSKJrJr "SS\5r"SS\5r g)N)messageschecker)TestCaseskipc\rSrSrSrSrSrSrSr\ "S5S5r S r S r S r S r\ "S5S 5r\ "S5S5rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!\ "S 5S!5r"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.r/S/r0S0r1S1r2S2r3S3r4S4r5S5r6S6r7S7r8S8r9S9r:S:r;S;rS>r?S?r@S@rASArBSBrCSCrDSDrESErFSFrGgG)HTestcDURS[R5 g)Nbarflakesm UndefinedNameselfs Z/var/www/html/KUNJ/venv/lib/python3.13/site-packages/pyflakes/test/test_undefined_names.pytest_undefinedTest.test_undefineds E1??+c&URS5 g)Nz for a in range(10) if a]r rs rtest_definedInListCompTest.test_definedInListComp s 12rcDURS[R5 g)Nz2 [a for a in range(10)] a r rs rtest_undefinedInListCompTest.test_undefinedInListComps  OO  %rcbURS[R[R5 g)zpException names can't be used after the except: block. The exc variable is unused inside the exception handler.zx try: raise ValueError('ve') except ValueError as exc: pass exc Nr rrUnusedVariablers rtest_undefinedExceptionName Test.test_undefinedExceptionNames&  __a..  0rc&URS5 g)zLocals declared in except: blocks can be used after the block. This shows the example in test_undefinedExceptionName is different.zy try: raise ValueError('ve') except ValueError as exc: e = exc e Nrrs r test_namesDeclaredInExceptBlocks%Test.test_namesDeclaredInExceptBlocks!   rz5error reporting disabled due to false positives belowcDURS[R5 g)zException names obscure locals, can't be used after. Last line will raise UnboundLocalError on Python 3 after exiting the except: block. Note next two examples for false positives to watch out for.z exc = 'Original value' try: raise ValueError('ve') except ValueError as exc: pass exc Nr rs r1test_undefinedExceptionNameObscuringLocalVariable6Test.test_undefinedExceptionNameObscuringLocalVariable.s  OO %rcbURS[R[R5 g)zException names are unbound after the `except:` block. Last line will raise UnboundLocalError. The exc variable is unused inside the exception handler. z try: raise ValueError('ve') except ValueError as exc: pass print(exc) exc = 'Original value' Nrrs r2test_undefinedExceptionNameObscuringLocalVariable27Test.test_undefinedExceptionNameObscuringLocalVariable2?s&  __a.. 0rcDURS[R5 g)zException names obscure locals, can't be used after. Unless. Last line will never raise UnboundLocalError because it's only entered if no exception was raised.z exc = 'Original value' try: raise ValueError('ve') except ValueError as exc: print('exception logged') raise exc Nr rrrs r?test_undefinedExceptionNameObscuringLocalVariableFalsePositive1DTest.test_undefinedExceptionNameObscuringLocalVariableFalsePositive1N     rc&URS5 g)z7The exception name can be deleted in the except: block.z\ try: pass except Exception as exc: del exc Nrrs rtest_delExceptionInExceptTest.test_delExceptionInExcept]   rcDURS[R5 g)zException names obscure locals, can't be used after. Unless. Last line will never raise UnboundLocalError because `error` is only falsy if the `except:` block has not been entered.z exc = 'Original value' error = None try: raise ValueError('ve') except ValueError as exc: error = 'exception logged' if error: print(error) else: exc Nr-rs r?test_undefinedExceptionNameObscuringLocalVariableFalsePositive2DTest.test_undefinedExceptionNameObscuringLocalVariableFalsePositive2fs     rcDURS[R5 g)zException names obscure globals, can't be used after. Last line will raise UnboundLocalError because the existence of that exception name creates a local scope placeholder for it, obscuring any globals, etc.z exc = 'Original value' def func(): try: pass # nothing is raised except ValueError as exc: pass # block never entered, exc stays unbound exc Nr rUndefinedLocalrs r2test_undefinedExceptionNameObscuringGlobalVariable7Test.test_undefinedExceptionNameObscuringGlobalVariablexs   $$ &rcDURS[R5 g)agException names obscure globals, can't be used after. Last line will raise NameError on Python 3 because the name is locally unbound after the `except:` block, even if it's nonlocal. We should issue an error in this case because code only working correctly if an exception isn't raised, is invalid. Unless it's explicitly silenced, see false positives below.a exc = 'Original value' def func(): global exc try: raise ValueError('ve') except ValueError as exc: pass # block never entered, exc stays unbound exc Nr9rs r3test_undefinedExceptionNameObscuringGlobalVariable28Test.test_undefinedExceptionNameObscuringGlobalVariable2s   $$ &rcDURS[R5 g)zException names obscure globals, can't be used after. Unless. Last line will never raise NameError because it's only entered if no exception was raised.a exc = 'Original value' def func(): global exc try: raise ValueError('ve') except ValueError as exc: print('exception logged') raise exc Nr-rs r@test_undefinedExceptionNameObscuringGlobalVariableFalsePositive1ETest.test_undefinedExceptionNameObscuringGlobalVariableFalsePositive1s     rcDURS[R5 g)zException names obscure globals, can't be used after. Unless. Last line will never raise NameError because `error` is only falsy if the `except:` block has not been entered.aN exc = 'Original value' def func(): global exc error = None try: raise ValueError('ve') except ValueError as exc: error = 'exception logged' if error: print(error) else: exc Nr-rs r@test_undefinedExceptionNameObscuringGlobalVariableFalsePositive2ETest.test_undefinedExceptionNameObscuringGlobalVariableFalsePositive2s     rc&URS5 g)NzQ class a: def b(): fu fu = 1 rrs rtest_functionsNeedGlobalScope"Test.test_functionsNeedGlobalScopes   rc&URS5 g)Nz range(10)rrs r test_builtinsTest.test_builtinss K rc&URS5 g)zU C{WindowsError} is sometimes a builtin name, so no warning is emitted for using it. WindowsErrorNrrs rtest_builtinWindowsErrorTest.test_builtinWindowsError N#rc&URS5 g)z Use of the C{__annotations__} in module scope should not emit an undefined name warning when version is greater than or equal to 3.6. __annotations__Nrrs rtest_moduleAnnotationsTest.test_moduleAnnotationss %&rc&URS5 g)zP Use of the C{__file__} magic global should not emit an undefined name warning. __file__Nrrs rtest_magicGlobalsFileTest.test_magicGlobalsFile Jrc&URS5 g)zT Use of the C{__builtins__} magic global should not emit an undefined name warning. __builtins__Nrrs rtest_magicGlobalsBuiltinsTest.test_magicGlobalsBuiltinsrPrc&URS5 g)zP Use of the C{__name__} magic global should not emit an undefined name warning. __name__Nrrs rtest_magicGlobalsNameTest.test_magicGlobalsNamerYrcdURS[R5 URSSS9 g)z Use of the C{__path__} magic global should not emit an undefined name warning, if you refer to it from a file called __init__.py. __path__zpackage/__init__.py)filenameNr rs rtest_magicGlobalsPathTest.test_magicGlobalsPaths' J0 J)> ?rcURS[R5 URS5 URS[R5 g)zj Use of the C{__module__} magic builtin should not emit an undefined name warning if used in class scope. __module__z3 class Foo: __module__ zR class Foo: def bar(self): __module__ Nr rs rtest_magicModuleInClassScope!Test.test_magicModuleInClassScopesC L!//2     __  rcURS[R5 URS5 URS[R5 g)zl Use of the C{__qualname__} magic builtin should not emit an undefined name warning if used in class scope. __qualname__z5 class Foo: __qualname__ zT class Foo: def bar(self): __qualname__ Nr rs rtest_magicQualnameInClassScope#Test.test_magicQualnameInClassScope sC NAOO4     __  rcbURS[R[R5 g)z)Can't find undefined names with import *.zfrom fu import *; barN)r rImportStarUsedImportStarUsagers rtest_globalImportStarTest.test_globalImportStars" +$$a&7&7 9rcHURS5 URS5 g)zL "global" can make an otherwise undefined name in another function defined. z@ def a(): global fu; fu = 1 def b(): fu zC def c(): bar def b(): global bar; bar = 1 Nrrs rtest_definedByGlobalTest.test_definedByGlobals(      rc&URS5 g)z% "global" can accept multiple names. zS def a(): global fu, bar; fu = 1; bar = 2 def b(): fu; bar Nrrs r!test_definedByGlobalMultipleNames&Test.test_definedByGlobalMultipleNames-s   rcDURS[R5 g)z4 A global statement in the global scope is ignored. zB global x def foo(): print(x) Nr rs rtest_globalInGlobalScopeTest.test_globalInGlobalScope6s  __  rcbURS[R[R5 g)z@A global statement does not prevent other names being undefined.zQ def f1(): s def f2(): global m N)r rrUnusedIndirectAssignmentrs rtest_global_reset_name_only Test.test_global_reset_name_only@s&  __a88  :rtodocDURS[R5 g)z4An unused global statement does not define the name.zQ def f1(): m def f2(): global m Nr rs rtest_unused_globalTest.test_unused_globalLs  __  rcDURS[R5 g)zDel deletes bindings.za = 1; del a; aNr rs rtest_del Test.test_delWs %q7rc&URS5 g)z%Del a global binding from a function.zY a = 1 def f(): global a del a a Nrrs rtest_delGlobalTest.test_delGlobal[s   rcDURS[R5 g)zDel an undefined name.zdel aNr rs rtest_delUndefinedTest.test_delUndefinedes GQ__-rc&URS5 g)z( Ignores conditional bindings deletion. zq context = None test = True if False: del(test) assert(test) Nrrs rtest_delConditionalTest.test_delConditionalis   rc&URS5 g)zP Ignored conditional bindings deletion even if they are nested in other blocks. z context = None test = True if False: with context(): del(test) assert(test) Nrrs rtest_delConditionalNestedTest.test_delConditionalNestedus   rc&URS5 g)zJ Ignore bindings deletion if called inside the body of a while statement. z~ def test(): foo = 'bar' while False: del foo assert(foo) Nrrs r test_delWhileTest.test_delWhiler%rc&URS5 g)zt Ignore bindings deletion if called inside the body of a while statement and name is used inside while's test part. z def _worker(): o = True while o is not True: del o o = False Nrrs rtest_delWhileTestUsageTest.test_delWhileTestUsager%rc&URS5 g)z` Ignore bindings deletions if node is part of while's test, even when del is in a nested block. z context = None def _worker(): o = True while o is not True: while True: with context(): del o o = False Nrrs rtest_delWhileNestedTest.test_delWhileNesteds  rc&URS5 g)z.Global names are available from nested scopes.zO a = 1 def b(): def c(): a Nrrs rtest_globalFromNestedScopeTest.test_globalFromNestedScoper4rcDURS[R5 g)zf Test that referencing a local name that shadows a global, before it is defined, generates a warning. z_ a = 1 def fun(): a a = 2 return a Nr9rs r(test_laterRedefinedGlobalFromNestedScope-Test.test_laterRedefinedGlobalFromNestedScopes      rcbURS[R[R5 g)z Test that referencing a local name in a nested scope that shadows a global declared in an enclosing scope, before it is defined, generates a warning. z a = 1 def fun(): global a def fun2(): a a = 2 return a N)r rr:r~rs r)test_laterRedefinedGlobalFromNestedScope2.Test.test_laterRedefinedGlobalFromNestedScope2s(    q99 ;rcDURS[R5 g)z If a name defined in an enclosing scope is shadowed by a local variable and the name is used locally before it is bound, an unbound local warning is emitted, even if there is a class scope between the enclosing scope and the local scope. z def f(): x = 1 class g: def h(self): a = x x = None print(x, a) print(x) Nr9rs r"test_intermediateClassScopeIgnored'Test.test_intermediateClassScopeIgnoreds      rcURS[R5RSnUR(aSOSnUR UR SU45 g)z Test that referencing a local name in a nested scope that shadows a variable declared in two different outer scopes before it is defined in the innermost scope generates an UnboundLocal warning which refers to the nearest shadowed name. a def a(): x = 1 def b(): x = 2 # line 5 def c(): x x = 3 return x return x return x rr xN)r rr:r withDoctest assertEqual message_args)rexcexpected_line_nums r$test_doubleNestingReportsClosestName)Test.test_doubleNestingReportsClosestNames^kk      (x +"&!1!1Aq ))C1B+CDrcDURS[R5 g)zx Test that referencing a local name in a nested scope that shadows a global, before it is defined, generates a warning. z def fun(): a = 1 def fun2(): a a = 1 return a return a Nr9rs r)test_laterRedefinedGlobalFromNestedScope3.Test.test_laterRedefinedGlobalFromNestedScope3r0rcURS[R[R[R[R[R5 g)Nz def f(seq): a = 0 seq[a] += 1 seq[b] /= 2 c[0] *= 2 a -= 3 d += 4 e[any] = 5 rrs r!test_undefinedAugmentedAssignment&Test.test_undefinedAugmentedAssignment s9   OO OO OOQ-- OO rc&URS5 g)z*Nested classes can access enclosing scope.z def f(foo): class C: bar = foo def f(self): return foo return C() f(123).f() Nrrs rtest_nestedClassTest.test_nestedClasss  rcDURS[R5 g)z=Free variables in nested classes must bind at class creation.z def f(): class C: bar = foo foo = 456 return foo f() Nr rs rtest_badNestedClassTest.test_badNestedClass,s  __ rc&URS5 g)z+Star and double-star arg names are defined.z? def f(a, *b, **c): print(a, b, c) Nrrs rtest_definedAsStarArgsTest.test_definedAsStarArgs7s   rcjURS5 URS5 URS5 g)z!Star names in unpack are defined.z7 a, *b = range(10) print(a, b) z7 *a, b = range(10) print(a, b) z= a, *b, c = range(10) print(a, b, c) Nrrs rtest_definedAsStarUnpackTest.test_definedAsStarUnpack>s9         rcjURS5 URS5 URS5 g)zC Star names in unpack are used if RHS is not a tuple/list literal. z8 def f(): a, *b = range(10) z: def f(): (*a, b) = range(10) z= def f(): [a, *b, c] = range(10) Nrrs rtest_usedAsStarUnpackTest.test_usedAsStarUnpackMs;         rc<URS[R[R5 URS[R[R5 URS[R[R[R5 g)zA Star names in unpack are unused if RHS is a tuple/list literal. zC def f(): a, *b = any, all, 4, 2, 'un' zL def f(): (*a, b) = [bool, int, float, complex] zD def f(): [a, *b, c] = 9, 8, 7, 6, 5, 4 Nr-rs rtest_unusedAsStarUnpackTest.test_unusedAsStarUnpack^s}    q// 1    q// 1    q//1A1A CrcHURS5 URS5 g)z#Keyword-only arg names are defined.z> def f(*, a, b=None): print(a, b) z\ import default_b def f(*, a, b=default_b): print(a, b) Nrrs rtest_keywordOnlyArgsTest.test_keywordOnlyArgsos&     rcDURS[R5 g)zTypo in kwonly name.zC def f(*, a, b=default_c): print(a, b) Nr rs rtest_keywordOnlyArgsUndefined"Test.test_keywordOnlyArgsUndefined|s  __ rcHURS5 URS5 g)zUndefined annotations.z from abc import note1, note2, note3, note4, note5 def func(a: note1, *args: note2, b: note3=12, **kw: note4) -> note5: pass zk def func(): d = e = 42 def func(a: {1, d}) -> (lambda c: e): pass Nrrs rtest_annotationUndefinedTest.test_annotationUndefineds&     rc&URS5 g)NzR from abc import ABCMeta class A(metaclass=ABCMeta): pass rrs rtest_metaClassUndefinedTest.test_metaClassUndefineds   rcHURS5 URS5 g)zK Using the loop variable of a generator expression results in no warnings. z(a for a in [1, 2, 3] if a)z-(b for b in (a for a in [1, 2, 3] if a) if b)Nrrs rtest_definedInGenExpTest.test_definedInGenExps 12 CDrcURS[R5 URS[R5 g)ze The loop variables of generator expressions nested together are not defined in the other generator. z-(b for b in (a for a in [1, 2, 3] if b) if b)z-(b for b in (a for a in [1, 2, 3] if a) if a)Nr rs rtest_undefinedInGenExpNested!Test.test_undefinedInGenExpNesteds2 COO % COO %rcURS5 URS5 URS[R5 URS[R5 g)zZ Some compatibility code checks explicitly for NameError. It should not trigger warnings. zc try: socket_map except NameError: socket_map = {} z try: _memoryview.contiguous except (NameError, AttributeError): raise RuntimeError("Python >= 3.3 is required") zY try: socket_map except: socket_map = {} zc try: socket_map except Exception: socket_map = {} Nr rs rtest_undefinedWithErrorHandler#Test.test_undefinedWithErrorHandlers`       __    __  rcHURS5 URS5 g)zD Defined name for generator expressions and dict/set comprehension. z class A: T = range(10) Z = (x for x in T) L = [x for x in T] B = dict((i, str(i)) for i in T) zu class A: T = range(10) X = {x for x in T} Y = {x:x for x in T} Nrrs rtest_definedInClassTest.test_definedInClasss(      rc&URS5 g)z9Defined name for nested generator expressions in a class.za class A: T = range(10) Z = (x for x in (a for a in T)) Nrrs rtest_definedInClassNestedTest.test_definedInClassNestedr4rcURS[R5 URS[R5 URS[R5 g)z@ The loop variable is defined after the expression is computed. z9 for i in range(i): print(i) z( [42 for i in range(i)] z( (42 for i in range(i)) Nr rs rtest_undefinedInLoopTest.test_undefinedInLoopsR  __   __   __ rc&URS5 g)zQ Defined name referenced from a lambda function within a dict/set comprehension. z4 {lambda: id(x) for x in range(10)} Nrrs r/test_definedFromLambdaInDictionaryComprehension4Test.test_definedFromLambdaInDictionaryComprehension   rc&URS5 g)zO Defined name referenced from a lambda function within a generator expression. z7 any(lambda: id(x) for x in range(10)) Nrrs r!test_definedFromLambdaInGenerator&Test.test_definedFromLambdaInGeneratorrrcDURS[R5 g)zS Undefined name referenced from a lambda function within a dict/set comprehension. z4 {lambda: id(y) for x in range(10)} Nr rs r1test_undefinedFromLambdaInDictionaryComprehension6Test.test_undefinedFromLambdaInDictionaryComprehension   __ rcDURS[R5 g)zQ Undefined name referenced from a lambda function within a generator expression. z7 any(lambda: id(y) for x in range(10)) Nr rs r'test_undefinedFromLambdaInComprehension,Test.test_undefinedFromLambdaInComprehensionrrc*SnURU5 g)Nz class Test(object): def __init__(self): print(__class__.__name__) self.x = 1 t = Test() r)rcodes rtest_dunderClassTest.test_dunderClasss  DrN)Hr_rhrl__firstlineno__rrrr r#rr'r*r.r2r6r;r>rArDrGrJrNrSrWr\r`rerirmrrrurxr{rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr__static_attributes__rrrrrs,3% 0   AB%C% 0  $ AB&C&" AB&C&("( !$' $ @  9    : &\8 .           ; $E2  $       "C"     E %> *     rrc\rSrSrSrSrSrg) NameTestsi'z. Tests for some extra cases of name handling. c[R"S5n[5URSRSlUR [[RU5 g)zR A Name node with an unrecognized context results in a RuntimeError being raised. zx = 10rN) astparseobjectbodytargetsctx assertRaises RuntimeErrorrChecker)rtrees rtest_impossibleContext NameTests.test_impossibleContext+sE yy"&,h ! Q# ,>rrN)r_rhrlr__doc__r rrrrrr's ?rr) rpyflakesrrrpyflakes.test.harnessrrrrrrrrs) +0] 8] @ ? ?r