şg~SSKJr SSKJrJrJrJrJr SSK J r J r "SS\ 5r "SS\ 5r "SS \ 5rg ) )messages)FutureImportation ImportationImportationFromStarImportationSubmoduleImportation)TestCaseskipcz\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrg)TestImportationObject cd[SSS5nURS:Xde[U5S:Xdeg)Nazimport arsource_statementstrselfbindings [/var/www/blue/EV-Temp_rev04/venv/lib/python3.13/site-packages/pyflakes/test/test_imports.pytest_import_basic'TestImportationObject.test_import_basics6c4-'':5557|s"""cd[SSS5nURS:Xde[U5S:Xdeg)Ncrz import a as cza as crrs rtest_import_as$TestImportationObject.test_import_ass6c4-''?:::7|x'''rcb[SS5nURS:Xde[U5S:Xdeg)Na.bz import a.b)rrrrs rtest_import_submodule+TestImportationObject.test_import_submodules4&ud3''<7777|u$$$rcd[SSS5nURS:Xde[U5S:Xdeg)Nrrzimport a.b as ca.b as crrs rtest_import_submodule_as.TestImportationObject.test_import_submodule_ass7c4/''+<<<<7|z)))rcd[SSS5nURS:Xde[U5S:Xdeg)Nrrzimport a.b as aza.b as arrs r$test_import_submodule_as_source_name:TestImportationObject.test_import_submodule_as_source_name#s7c4/''+<<<<7|z)))rcf[SSSS5nURS:Xde[U5S:Xdeg)Nr.zfrom . import az.arrrrs rtest_importfrom_relative.TestImportationObject.test_importfrom_relative(s9!#tS#6''+<<<<7|t###rcf[SSSS5nURS:Xde[U5S:Xdeg)Nr..zfrom .. import a..ar+rs rtest_importfrom_relative_parent5TestImportationObject.test_importfrom_relative_parent-s9!#tT37''+====7|u$$$rcf[SSSS5nURS:Xde[U5S:Xdeg)Nbr0zfrom ..a import bz..a.br+rs r$test_importfrom_relative_with_module:TestImportationObject.test_importfrom_relative_with_module29!#tUC8''+>>>>7|w&&&rcf[SSSS5nURS:Xde[U5S:Xdeg)Nrr0r4zfrom ..a import b as cz ..a.b as cr+rs r'test_importfrom_relative_with_module_as=TestImportationObject.test_importfrom_relative_with_module_as79!#tUC8''+CCCC7||+++rcf[SSSS5nURS:Xde[U5S:Xdeg)Nr4rzfrom a import brr+rs rtest_importfrom_member,TestImportationObject.test_importfrom_member<s9!#tS#6''+<<<<7|u$$$rcf[SSSS5nURS:Xde[U5S:Xdeg)Nrrzfrom a.b import cza.b.cr+rs r test_importfrom_submodule_member6TestImportationObject.test_importfrom_submodule_memberAr7rcf[SSSS5nURS:Xde[U5S:Xdeg)Nrrr4zfrom a import b as cr#r+rs rtest_importfrom_member_as/TestImportationObject.test_importfrom_member_asFs9!#tS#6''+AAAA7|z)))rcf[SSSS5nURS:Xde[U5S:Xdeg)Ndrrzfrom a.b import c as dz a.b.c as dr+rs r#test_importfrom_submodule_member_as9TestImportationObject.test_importfrom_submodule_member_asKr;rcb[SS5nURS:Xde[U5S:Xdeg)Nrzfrom a.b import *za.b.*rrrrs rtest_importfrom_star*TestImportationObject.test_importfrom_starPs5!%.''+>>>>7|w&&&rcb[SS5nURS:Xde[U5S:Xdeg)Nz.bzfrom .b import *z.b.*rJrs rtest_importfrom_star_relative3TestImportationObject.test_importfrom_star_relativeUs5!$-''+====7|v%%%rcd[SSS5nURS:Xde[U5S:Xdeg)Nprint_functionz%from __future__ import print_functionz__future__.print_function)rrrrs rtest_importfrom_future,TestImportationObject.test_importfrom_futureZs9#$4dDA''+RRRR7|::::rcDURS[R5 g)zU The magic underscore var should be reported as unused when used as an import alias. zimport fu as _Nflakesm UnusedImportrs rtest_unusedImport_underscore2TestImportationObject.test_unusedImport_underscore_s $ann5rN)__name__ __module__ __qualname____firstlineno__rrr r$r'r,r1r5r9r=r@rCrGrKrNrRrZ__static_attributes__r\rrr r sW# ( % * * $ % ' , % ' * , ' & ; 6rr cv\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)r+S*r,S+r-S,r.S-r/S.r0S/r1S0r2S1r3S2r4S3r5S4r6S5r7S6r8S7r9S8r:S9r;S:rS=r?S>r@S?rAS@rBSArCSBrDSCrESDrFSErGSFrHSGrISHrJSIrKSJrLSKrMSLrNSMrOSNrPSOrQSPrRSQrSSRrTSSrUSTrVSUrWSVrXSWrYSXrZSYr[SZr\S[r]\^"S\5S]5r_S^r`S_raS`rbSarcSbrdScreSdrfSerggf)gTestgcURS[R[R5 URS[R[R5 g)Nzimport fu, barzfrom baz import fu, barrUrYs rtest_unusedImportTest.test_unusedImportis4 $annannE -q~~q~~NrcURS[R5 URS[R5 URS[R5 URS[R5 URS[R5 URS[R5 URS[R5 URS[R5 URS [R5 URS[R5nURS nURS :XdeUR S :XdeURS[R5nURS nURS :XdeUR S :Xdeg)Nzfrom . import fuzfrom . import fu as bazzfrom .. import fuzfrom ... import fuzfrom .. import fu as bazzfrom .bar import fuzfrom ..bar import fuzfrom ...bar import fuzfrom ...bar import fu as bazr%r imported but unusedz.fu)z .fu as baz)rVrWrXrmessage message_argsrcheckererrors rtest_unusedImport_relativeTest.test_unusedImport_relativemsF &7 -q~~> '8 (!..9 .? )1>>: *ANN; +Q^^< 2ANNC++0!..A  #}} 8888!!Y...++7H  #}} 8888!!%5555rcURS[R[R5 URS[R[R5 g)Nzimport fu as FU, bar as FUz#from moo import fu as FU, bar as FUrVrWRedefinedWhileUnusedrXrYs rtest_aliasedImportTest.test_aliasedImports> 0**ANN < 9**ANN rcURS[R5 URS[R5 URS[R5 g)Nzimport fu; fu = 3zimport fu; fu, bar = 3zimport fu; [fu, bar] = 3rVrWrtrYs rtest_redefinedWhileUnusedTest.test_redefinedWhileUnusedsA ')?)?@ ,a.D.DE .0F0FGrcDURS[R5 g)zM Test that importing a module twice within an if block does raise a warning. z[ i = 2 if i==1: import os import os os.pathNrrYs rtest_redefinedIfTest.test_redefinedIfs  **  ,rc&URS5 g)zT Test that importing a module twice in if and else blocks does not raise a warning. zi i = 2 if i==1: import os else: import os os.pathNrxrYs rtest_redefinedIfElseTest.test_redefinedIfElses  rcDURS[R5 g)zI Test that importing a module twice in a try block does raise a warning. zj try: import os import os except: pass os.pathNrrYs rtest_redefinedTryTest.test_redefinedTrys  **  ,rc&URS5 g)zX Test that importing a module twice in a try and except block does not raise a warning. zY try: import os except: import os os.pathNrxrYs rtest_redefinedTryExceptTest.test_redefinedTryExcepts  rc&URS5 g)zf Test that importing a module twice using a nested try/except and if blocks does not issue a warning. z try: if True: if True: import os except: import os os.pathNrxrYs rtest_redefinedTryNestedTest.test_redefinedTryNesteds  rc&URS5 g)Nz try: from aa import mixer except AttributeError: from bb import mixer except RuntimeError: from cc import mixer except: from dd import mixer mixer(123) rxrYs rtest_redefinedTryExceptMulti!Test.test_redefinedTryExceptMultis  rcDURS[R5 g)Nz try: from aa import mixer except ImportError: pass else: from bb import mixer mixer(123) rrYs rtest_redefinedTryElseTest.test_redefinedTryElses   # # %rc&URS5 g)Nz try: import funca except ImportError: from bb import funca from bb import funcb else: from bbb import funcb print(funca, funcb) rxrYs rtest_redefinedTryExceptElse Test.test_redefinedTryExceptElses  rc&URS5 g)Nz try: from aa import a except ImportError: from bb import a finally: a = 42 print(a) rxrYs rtest_redefinedTryExceptFinally#Test.test_redefinedTryExceptFinallys   rc&URS5 g)Nz try: import b except ImportError: b = Ellipsis from bb import a else: from aa import a finally: a = 42 print(a, b) rxrYs r"test_redefinedTryExceptElseFinally'Test.test_redefinedTryExceptElseFinallys  rcDURS[R5 g)Nz> import fu def fu(): pass rrYs rtest_redefinedByFunctionTest.test_redefinedByFunction   # #  %rcbURS[R[R5 g)Z Test that shadowing a global name with a nested function definition generates a warning. zx import fu def bar(): def baz(): def fu(): pass NrsrYs rtest_redefinedInNestedFunction#Test.test_redefinedInNestedFunction$s&   # #Q^^  5rcURS[R[R[R[R5 g)rz import fu def bar(): import fu def baz(): def fu(): pass NrsrYs r#test_redefinedInNestedFunctionTwice(Test.test_redefinedInNestedFunctionTwice1s5  **A,B,BNNANN 4rc&URS5 g)zt Test that a global import which is redefined locally, but used later in another scope does not generate a warning. aq import unittest, transport class GetTransportTestCase(unittest.TestCase): def test_get_transport(self): transport = 'transport' self.assertIsNotNone(transport) class TestTransportMethodArgs(unittest.TestCase): def test_send_defaults(self): transport.Transport() NrxrYs rtest_redefinedButUsedLaterTest.test_redefinedButUsedLaterAs  rcDURS[R5 g)Nz> import fu class fu: pass rrYs rtest_redefinedByClassTest.test_redefinedByClassSrrc&URS5 g)z{ If an imported name is redefined by a class statement which also uses that name in the bases list, no warning is emitted. zM from fu import bar class bar(bar): pass NrxrYs rtest_redefinedBySubclassTest.test_redefinedBySubclassZ   rc&URS5 g)zQ Test that shadowing a global with a class attribute does not produce a warning. zS import fu class bar: fu = 1 print(fu) NrxrYs rtest_redefinedInClassTest.test_redefinedInClasses   rcfURS5 URS[R5 g)z> Test that import within class is a locally scoped attribute. z2 class bar: import fu z> class bar: import fu fu NrVrW UndefinedNamerYs rtest_importInClassTest.test_importInClassqs1    __  rc&URS5 g)NzD import fu def fun(): print(fu) rxrYs rtest_usedInFunctionTest.test_usedInFunction   rcURS[R[R5 URS5 g)NzF import fu def fun(fu): print(fu) zX import fu def fun(fu): print(fu) print(fu) rVrWrXrtrYs rtest_shadowedByParameterTest.test_shadowedByParameters7  ^^Q33  5   rc&URS5 g)Nz fu = NonerxrYs rtest_newAssignmentTest.test_newAssignments K rcfURS5 URS[R5 g)Nzimport fu; fu.bar.bazzimport fu; "bar".fu.bazrUrYs rtest_usedInGetattrTest.test_usedInGetattrs" +, -q~~>rc&URS5 g)Nzimport fu; print(fu.bar[1:])rxrYs rtest_usedInSliceTest.test_usedInSlices 23rc&URS5 g)Nz6 import fu if True: print(fu) rxrYs rtest_usedInIfBodyTest.test_usedInIfBody   rc&URS5 g)Nz/ import fu if fu: pass rxrYs rtest_usedInIfConditionalTest.test_usedInIfConditionalrrc&URS5 g)NzH import fu if False: pass elif fu: pass rxrYs rtest_usedInElifConditionalTest.test_usedInElifConditionalrrc&URS5 g)NzJ import fu if False: pass else: print(fu) rxrYs rtest_usedInElseTest.test_usedInElserrc&URS5 g)Nzimport fu; fu.bar()rxrYs rtest_usedInCallTest.test_usedInCalls )*rc&URS5 g)NzC import fu class bar: bar = fu rxrYs rtest_usedInClassTest.test_usedInClassrrc&URS5 g)NzO import fu class bar(object, fu.baz): pass rxrYs rtest_usedInClassBaseTest.test_usedInClassBaserrc&URS5 g)NzR import fu def bleh(): pass print(fu) rxrYs rtest_notUsedInNestedScopeTest.test_notUsedInNestedScope   rc&URS5 g)NzN import fu for bar in range(9): print(fu) rxrYs rtest_usedInForTest.test_usedInForrrc&URS5 g)Nzn import fu for bar in range(10): pass else: print(fu) rxrYs rtest_usedInForElseTest.test_usedInForElse   rcDURS[R5 g)NzH import fu for fu in range(2): pass rVrWImportShadowedByLoopVarrYs rtest_redefinedByForTest.test_redefinedByFors   & &  (rcDURS[R5 g)zQ Test that shadowing a global name with a for loop variable generates a warning. zS import fu fu.bar() for fu in (): pass NrrYs rtest_shadowedByForTest.test_shadowedByFors   & &  (rcURS[R5 URS[R5 g)zj Test that shadowing a global name with a for loop variable nested in a tuple unpack generates a warning. zl import fu fu.bar() for (x, y, z, (a, b, c, (fu,))) in (): pass zl import fu fu.bar() for [x, y, z, (a, b, c, (fu,))] in (): pass NrrYs rtest_shadowedByForDeepTest.test_shadowedByForDeeps>   & &  (   & &  (rc&URS5 g)NzD import fu def fun(): return fu rxrYs rtest_usedInReturnTest.test_usedInReturn rrcURS5 URS5 URS5 URS5 URS5 URS5 URS5 URS5 URS 5 URS 5 URS 5 URS 5 URS 5 URS5 URS5 g)Nzimport fu; 3 + fu.barzimport fu; 3 % fu.barzimport fu; 3 - fu.barzimport fu; 3 * fu.barzimport fu; 3 ** fu.barzimport fu; 3 / fu.barzimport fu; 3 // fu.barzimport fu; -fu.barzimport fu; ~fu.barzimport fu; 1 == fu.barzimport fu; 1 | fu.barzimport fu; 1 & fu.barzimport fu; 1 ^ fu.barzimport fu; 1 >> fu.barzimport fu; 1 << fu.barrxrYs rtest_usedInOperatorsTest.test_usedInOperatorss +, +, +, +, ,- +, ,- () () ,- +, +, +, ,- ,-rc&URS5 g)Nzimport fu; assert fu.barrxrYs rtest_usedInAssertTest.test_usedInAssert!s ./rc&URS5 g)Nzimport fu; fu.bar[1]rxrYs rtest_usedInSubscriptTest.test_usedInSubscript$s *+rcjURS5 URS5 URS5 g)Nzimport fu; fu and Falsezimport fu; fu or Falsezimport fu; not fu.barrxrYs rtest_usedInLogicTest.test_usedInLogic's) -. ,- +,rc&URS5 g)Nzimport fu; [fu]rxrYs rtest_usedInListTest.test_usedInList,s %&rc&URS5 g)Nzimport fu; (fu,)rxrYs rtest_usedInTupleTest.test_usedInTuple/s &'rc&URS5 gNz@ import fu try: fu except: pass rxrYs rtest_usedInTryTest.test_usedInTry2rrc&URS5 grrxrYs rtest_usedInExceptTest.test_usedInExcept9rrc[R/nUR[R5 UR"S/UQ76 g)NzR import fu try: pass except Exception as fu: pass )rWrtappendUnusedVariablerV)rexpecteds rtest_redefinedByExceptTest.test_redefinedByExcept@s=**+(()     rc&URS5 g)Nz0 import fu raise fu.bar rxrYs rtest_usedInRaiseTest.test_usedInRaiseJrrc&URS5 g)NzC import fu def gen(): yield fu rxrYs rtest_usedInYieldTest.test_usedInYieldPrrcHURS5 URS5 g)Nzimport fu; {fu:None}zimport fu; {1:fu}rxrYs rtest_usedInDictTest.test_usedInDictWs *+ '(rc&URS5 g)NzC import fu def f(bar=fu): pass rxrYs rtest_usedInParameterDefault Test.test_usedInParameterDefault[rrc&URS5 g)Nzimport fu; fu.bar = 1rxrYs rtest_usedInAttributeAssignTest.test_usedInAttributeAssignb +,rc&URS5 g)Nzimport fu; fu.bar(stuff=fu)rxrYs rtest_usedInKeywordArgTest.test_usedInKeywordArges 12rcHURS5 URS5 g)Nzimport fu; bar=fuzimport fu; n=0; n+=furxrYs rtest_usedInAssignmentTest.test_usedInAssignmenths '( +,rcHURS5 URS5 g)Nz!import fu; [fu for _ in range(1)]z&import fu; [1 for _ in range(1) if fu]rxrYs rtest_usedInListCompTest.test_usedInListCompls 78 <=rcHURS5 URS5 g)NzA import fu try: pass finally: fu zA import fu try: fu finally: pass rxrYs rtest_usedInTryFinallyTest.test_usedInTryFinallyps&     rcHURS5 URS5 g)Nz; import fu while 0: fu z2 import fu while fu: pass rxrYs rtest_usedInWhileTest.test_usedInWhile}s&     rcDURS[R5 g)z\ A 'global' statement shadowing an unused import should not prevent it from being reported. z6 import fu def f(): global fu NrUrYs rtest_usedInGlobalTest.test_usedInGlobals  ^^ rc&URS5 g)z\ A 'global' statement shadowing a used import should not cause it to be reported as unused. zc import foo def f(): global foo def g(): foo.is_used() NrxrYs rtest_usedAndGlobalTest.test_usedAndGlobalrrc&URS5 g)zV Binding an import to a declared global should not cause it to be reported as unused. zX def f(): global foo; import foo def g(): foo.is_used() NrxrYs rtest_assignedToGlobalTest.test_assignedToGlobals   rc0SnURSU-5 g)Nzexec("print(1)", fu.bar)z import fu; %srx)r exec_stmts rtest_usedInExecTest.test_usedInExecs.  Oi/0rc&URS5 g)Nzimport fu; lambda: furxrYs rtest_usedInLambdaTest.test_usedInLambdar.rcURS[R[R5 URS5 g)Nzimport fu; lambda fu: fuzimport fu; lambda fu: fu fu()rrYs rtest_shadowedByLambdaTest.test_shadowedByLambdas- .NNA$:$: < 45rc&URS5 g)Nzimport fu; "meow"[::fu]rxrYs rtest_usedInSliceObjTest.test_usedInSliceObjs -.rcbURS[R[R5 g)Nz= def bar(): import fu fu )rVrWrXrrYs rtest_unusedInNestedScopeTest.test_unusedInNestedScopes"  ^^Q__  .rcDURS[R5 g)Nz` class bar: import fu def fun(self): fu rrYs rtest_methodsDontUseClassScope"Test.test_methodsDontUseClassScopes  __  rc&URS5 g)NzX def a(): def b(): fu import fu rxrYs rtest_nestedFunctionsNestScope"Test.test_nestedFunctionsNestScoperrc&URS5 g)Nz def a(): import fu class b: def c(self): print(fu) rxrYs r test_nestedClassAndFunctionScope%Test.test_nestedClassAndFunctionScoperrc URS[R[R5 URS[R[R5 URS[R[R5nURSnUR R S5(deURS:XdeURSnUR S:XdeURS:Xdeg ) z,Use of import * at module level is reported.zfrom fu import *zT try: from fu import * except: pass r 'from %s import *' used; unable )furi)zfu.*NrVrWImportStarUsedrXrrk startswithrlrms rtest_importStarTest.test_importStars &(8(8!..I    q~~  /++0..@  #}}''(JKKKK!!X---  #}} 8888!!Z///rcTURS[R[R5 URS[R[R5 URS[R[R5nURSnUR R S5(deURS:XdeURSnUR S:XdeURS:XdeURS [R[R5nURSnUR R S5(deURS :XdeURSnUR S:XdeURS :Xdeg ) z3Use of import * from a relative import is reported.zfrom .fu import *zU try: from .fu import * except: pass rrarjrcri)z.fu.*from .. import *r/)rjNrdrms rtest_importStar_relativeTest.test_importStar_relativesv ')9)91>>J    q~~  /++1..@  #}}''(JKKKK!!Y...  #}} 8888!![000++0..@  #}}''(JKKKK!!X---  #}} 8888!!%;;;;rc*URS[R5 URS[R5 URS[R5nURSnURS:XdeUR S:Xdeg)z)import * is only allowed at module level.z7 def a(): from fu import * z7 class a: from fu import * z7 class a: from .. import * rz/'from %s import *' only allowed at module levelrkN)rVrWImportStarNotPermittedrrkrlrms rtest_localImportStarTest.test_localImportStar s   % % '   % % ' ++  % %'  #}} QQQQ!!X---rc&URS5 g)z@ If a dotted name is imported and used, no warning is reported. z. import fu.bar fu.bar NrxrYs rtest_packageImportTest.test_packageImports   rcDURS[R5 g)zR If a dotted name is imported and not used, an unused import warning is reported. z import fu.barNrUrYs rtest_unusedPackageImportTest.test_unusedPackageImport(s OQ^^4rcURS[R5 URS[R5 g)z| If a submodule of a package is imported twice, an unused import warning and a redefined while unused warning are reported. z6 import fu.bar, fu.bar fu.bar zD import fu.bar import fu.bar fu.bar NrrYs rtest_duplicateSubmoduleImport"Test.test_duplicateSubmoduleImport/s>   # # %   # #  %rcHURS5 URS5 g)zq If two different submodules of a package are imported, no duplicate import warning is reported for the package. z> import fu.bar, fu.baz fu.bar, fu.baz zL import fu.bar import fu.baz fu.bar, fu.baz NrxrYs rtest_differentSubmoduleImport"Test.test_differentSubmoduleImport>s(      rcHURS5 URS5 g)z3 Usage of package marks submodule imports as used. z> import fu import fu.bar fu.x z> import fu.bar import fu fu.x NrxrYs r'test_used_package_with_submodule_import,Test.test_used_package_with_submodule_importM(     rcHURS5 URS5 g)z< Usage of package by alias marks submodule imports as used. zU import foo as f import foo.bar f.bar.do_something() z_ import foo as f import foo.bar.blah f.bar.blah.do_something() NrxrYs r0test_used_package_with_submodule_import_of_alias5Test.test_used_package_with_submodule_import_of_alias]rrcURS[R5nURSnURS:XdeUR S:XdeUR (aURS:Xdegg)zB When a package and its submodule are imported, only report once. z1 import fu import fu.bar rri)zfu.barN)rVrWrXrrkrl withDoctestlinenorms r)test_unused_package_with_submodule_import.Test.test_unused_package_with_submodule_importmsx++ ^^  #}} 8888!!\111$($4$4u||q ;;! rcURS5 URS5 URS5 URS5 g)Nzimport fu; fu = fuzimport fu; fu, bar = fuzimport fu; [fu, bar] = fuzimport fu; fu += furxrYs rtest_assignRHSFirstTest.test_assignRHSFirstzs6 () -. /0 )*rc&URS5 g)Nzp try: import fu except ImportError: import bar as fu fu rxrYs rtest_tryingMultipleImportsTest.test_tryingMultipleImportsrrc&URS5 g)Nz` import fu def a(): fu = 3 return fu fu rxrYs rtest_nonGlobalDoesNotRedefine"Test.test_nonGlobalDoesNotRedefinerrc&URS5 g)Nz; def a(): fu import fu rxrYs rtest_functionsRunLaterTest.test_functionsRunLaterrrcDURS[R5 g)NzG import fu def fu(): fu fu rrYs rtest_functionNamesAreBoundNow"Test.test_functionNamesAreBoundNows   # #  %rc&URS5 g)Nz a = 1; a = 2rxrYs r!test_ignoreNonImportRedefinitions&Test.test_ignoreNonImportRedefinitionss N#rtodoc&URS5 g)NzY try: import fu except ImportError: pass rxrYs rtest_importingForImportError!Test.test_importingForImportError   rc&URS5 g)z0Imports in class scope can be used through self.zf class c: import i def __init__(self): self.i NrxrYs rtest_importedInClassTest.test_importedInClassrrc&URS5 g)zG Method named 'foo' with default args referring to module named 'foo'. z import foo class Thing(object): def foo(self, parser=foo.parse_foo): pass NrxrYs r!test_importUsedInMethodDefinition&Test.test_importUsedInMethodDefinitions   rcHURS5 URS5 g)z__future__ is special.zfrom __future__ import divisionze "docstring is allowed before future import" from __future__ import division NrxrYs rtest_futureImportTest.test_futureImports  56   rcURS[R5 URS[R5 g)z4 __future__ imports must come before anything else. z? x = 5 from __future__ import division zY from foo import bar from __future__ import division bar N)rVrWLateFutureImportrYs rtest_futureImportFirstTest.test_futureImportFirsts>     !      !rc&URS5 g)z?__future__ is special, but names are injected in the namespace.z from __future__ import division from __future__ import print_function assert print_function is not division NrxrYs rtest_futureImportUsedTest.test_futureImportUsedrrcDURS[R5 g)z0Importing undefined names from __future__ fails.z8 from __future__ import print_statement NrVrWFutureFeatureNotDefinedrYs rtest_futureImportUndefinedTest.test_futureImportUndefined   & & (rcDURS[R5 g)z$Importing '*' from __future__ fails.z* from __future__ import * NrrYs rtest_futureImportStarTest.test_futureImportStarrrr\N)hr]r^r_r`rfrpruryr|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrr r#r&r)r,r0r3r6r9r<r?rBrErIrLrOrRrUrXr[r^rgrlrprsrvryr|rrrrrrrrrr rrrrrrrrrar\rrrcrcgsO6.< / ) ? H ,  ,     %      % 54  $%        !?4    +     ( ((& ."0,- '(    ) -3->       1-6 /.  0*<@.& 5 %    <+    %$ &\       ! ( (rrcc\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrg)TestSpecialAlliz@ Tests for suppression of unused import warnings by C{__all__}. cbURS[R[R5 g)zX An C{__all__} definition does not suppress unused import warnings in a function scope. zQ def foo(): import bar __all__ = ["bar"] N)rVrWrXrrYs rtest_ignoredInFunction%TestSpecialAll.test_ignoredInFunctions&  ^^Q--  /rcDURS[R5 g)zO An C{__all__} definition in a class does not suppress unused import warnings. zM import bar class foo: __all__ = ["bar"] NrUrYs rtest_ignoredInClass"TestSpecialAll.test_ignoredInClasss  ^^  rcDURS[R5 g)Nz: import bar (__all__,) = ("foo",) rUrYs r'test_ignored_when_not_directly_assigned6TestSpecialAll.test_ignored_when_not_directly_assigneds  ^^ rcHURS5 URS5 g)zV If a name is imported and unused but is named in C{__all__}, no warning is reported. z6 import foo __all__ = ["foo"] z7 import foo __all__ = ("foo",) NrxrYs rtest_warningSuppressed%TestSpecialAll.test_warningSuppressed s(      rcbURS[R[R5 g)z3 The C{__all__} variable is defined incrementally. z import a import c __all__ = ['a'] __all__ += ['b'] if 1 < 3: __all__ += ['c', 'd'] NrVrWUndefinedExportrYs rtest_augmentedAssignment'TestSpecialAll.test_augmentedAssignments(     1 1 3rcURS[R[R[R[R5 g)z@ The C{__all__} variable is defined through list concatenation. zD import sys __all__ = ['a'] + ['b'] + ['c'] NrVrWrrXrYs r"test_list_concatenation_assignment1TestSpecialAll.test_list_concatenation_assignment(7     1 113D3Dann VrcURS[R[R[R[R5 g)zA The C{__all__} variable is defined through tuple concatenation. zG import sys __all__ = ('a',) + ('b',) + ('c',) NrrYs r#test_tuple_concatenation_assignment2TestSpecialAll.test_tuple_concatenation_assignment1rrc&URS5 g)NzF from foo import bar __all__ = [bar.__name__] rxrYs rtest_all_with_attributes'TestSpecialAll.test_all_with_attributes:rrc&URS5 g)Nz= from foo import bar __all__ = [bar] rxrYs rtest_all_with_names"TestSpecialAll.test_all_with_names@s   rc&URS5 g)Nzs from foo import bar from bar import baz __all__ = [bar.__name__] + [baz.__name__] rxrYs rtest_all_with_attributes_added-TestSpecialAll.test_all_with_attributes_addedGrrc&URS5 g)Nzi from foo import bar from foo import baz __all__ = ['bar', baz.__name__] rxrYs r%test_all_mixed_attributes_and_strings4TestSpecialAll.test_all_mixed_attributes_and_stringsNrrcvURS[R5 SHnURSUS9 M g)zI If C{__all__} includes a name which is not bound, a warning is emitted. z# __all__ = ["foo"] )zfoo/__init__.pyz __init__.pyz+ __all__ = ["foo"] )filenameNr)rrs rtest_unboundExported#TestSpecialAll.test_unboundExportedUsC     ;H KK"  $;rcURS[R[R[R[R5 g)z& Report undefined if import * is used zT from math import * __all__ = ['sin', 'cos'] csc(1) N)rVrWreImportStarUsagerYs rtest_importStarExported&TestSpecialAll.test_importStarExportedds9    q00!2C2CQEVEV  XrcbURS[R[R5 g)z8Report unused import when not needed to satisfy __all__.zL from foolib import * a = 1 __all__ = ['a'] N)rVrWrerXrYs rtest_importStarNotExported)TestSpecialAll.test_importStarNotExportedns$    q~~  /rcHURS5 URS5 g)zB Using a global in a generator expression results in no warnings. z!import fu; (fu for _ in range(1))z&import fu; (1 for _ in range(1) if fu)NrxrYs rtest_usedInGenExp TestSpecialAll.test_usedInGenExpvs 78 <=rcbURS[R[R5 g)zk Re-using a global name as the loop variable for a generator expression results in a redefinition warning. z!import fu; (1 for fu in range(1))NrsrYs rtest_redefinedByGenExp%TestSpecialAll.test_redefinedByGenExp}s" 7**ANN <4rrN)pyflakesrrWpyflakes.checkerrrrrrpyflakes.test.harnessr r r rcrr\rrrsC"1X6HX6vD(8D(NIXIr