jSSKJr SSKJr SSKJrJrJrJ r J r SSK J r J r Jr "SS\ 5r"SS\ 5r"S S \ 5rg ) ) version_info)messages)FutureImportation ImportationImportationFromStarImportationSubmoduleImportation)TestCaseskipskipIfcz\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrg)TestImportationObjectcd[SSS5nURS:Xde[U5S:Xdeg)Nazimport arsource_statementstrselfbindings R/var/www/html/KUNJ/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)r rrrs rtest_import_submodule+TestImportationObject.test_import_submodules4&ud3''<7777|u$$$rcd[SSS5nURS:Xde[U5S:Xdeg)Nrr!zimport a.b as ca.b as crrs rtest_import_submodule_as.TestImportationObject.test_import_submodule_ass7c4/''+<<<<7|z)))rcd[SSS5nURS:Xde[U5S:Xdeg)Nrr!zimport 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)Nbr2zfrom ..a import bz..a.br-rs r$test_importfrom_relative_with_module:TestImportationObject.test_importfrom_relative_with_module49!#tUC8''+>>>>7|w&&&rcf[SSSS5nURS:Xde[U5S:Xdeg)Nrr2r6zfrom ..a import b as cz ..a.b as cr-rs r'test_importfrom_relative_with_module_as=TestImportationObject.test_importfrom_relative_with_module_as99!#tUC8''+CCCC7||+++rcf[SSSS5nURS:Xde[U5S:Xdeg)Nr6rzfrom a import br!r-rs rtest_importfrom_member,TestImportationObject.test_importfrom_member>s9!#tS#6''+<<<<7|u$$$rcf[SSSS5nURS:Xde[U5S:Xdeg)Nrr!zfrom a.b import cza.b.cr-rs r test_importfrom_submodule_member6TestImportationObject.test_importfrom_submodule_memberCr9rcf[SSSS5nURS:Xde[U5S:Xdeg)Nrrr6zfrom a import b as cr%r-rs rtest_importfrom_member_as/TestImportationObject.test_importfrom_member_asHs9!#tS#6''+AAAA7|z)))rcf[SSSS5nURS:Xde[U5S:Xdeg)Ndr!rzfrom a.b import c as dz a.b.c as dr-rs r#test_importfrom_submodule_member_as9TestImportationObject.test_importfrom_submodule_member_asMr=rcb[SS5nURS:Xde[U5S:Xdeg)Nr!zfrom a.b import *za.b.*rrrrs rtest_importfrom_star*TestImportationObject.test_importfrom_starRs5!%.''+>>>>7|w&&&rcb[SS5nURS:Xde[U5S:Xdeg)Nz.bzfrom .b import *z.b.*rLrs rtest_importfrom_star_relative3TestImportationObject.test_importfrom_star_relativeWs5!$-''+====7|v%%%rcd[SSS5nURS:Xde[U5S:Xdeg)Nprint_functionz%from __future__ import print_functionz__future__.print_function)rrrrs rtest_importfrom_future,TestImportationObject.test_importfrom_future\s9#$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_underscoreas $ann5rN)__name__ __module__ __qualname____firstlineno__rrr"r&r)r.r3r7r;r?rBrErIrMrPrTr\__static_attributes__r^rrrrsW# ( % * * $ % ' , % ' * , ' & ; 6rrc\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`rbSarcSbrd\e"\fSc:Sd5Se5rg\e"\fSc:Sd5Sf5rhSgrigh)iTesticURS[R[R5 URS[R[R5 g)Nzimport fu, barzfrom baz import fu, barrWr[s rtest_unusedImportTest.test_unusedImportks4 $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)rXrYrZrmessage message_argsrcheckererrors rtest_unusedImport_relativeTest.test_unusedImport_relativeosF &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 FUrXrYRedefinedWhileUnusedrZr[s 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] = 3rXrYrvr[s 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.pathNrr[s 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.pathNrzr[s 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.pathNrr[s 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.pathNrzr[s 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.pathNrzr[s 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) rzr[s rtest_redefinedTryExceptMulti!Test.test_redefinedTryExceptMultis  rcDURS[R5 g)Nz try: from aa import mixer except ImportError: pass else: from bb import mixer mixer(123) rr[s 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) rzr[s 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) rzr[s 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) rzr[s r"test_redefinedTryExceptElseFinally'Test.test_redefinedTryExceptElseFinallys  rcDURS[R5 g)Nz> import fu def fu(): pass rr[s 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 Nrur[s 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 Nrur[s r#test_redefinedInNestedFunctionTwice(Test.test_redefinedInNestedFunctionTwice3s5  **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() Nrzr[s rtest_redefinedButUsedLaterTest.test_redefinedButUsedLaterCs  rcDURS[R5 g)Nz> import fu class fu: pass rr[s rtest_redefinedByClassTest.test_redefinedByClassUrrc&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 Nrzr[s rtest_redefinedBySubclassTest.test_redefinedBySubclass\s   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) Nrzr[s rtest_redefinedInClassTest.test_redefinedInClassgs   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 NrXrY UndefinedNamer[s rtest_importInClassTest.test_importInClassss1    __  rc&URS5 g)NzD import fu def fun(): print(fu) rzr[s 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) rXrYrZrvr[s rtest_shadowedByParameterTest.test_shadowedByParameters7  ^^Q33  5   rc&URS5 g)Nz fu = Nonerzr[s rtest_newAssignmentTest.test_newAssignments K rcfURS5 URS[R5 g)Nzimport fu; fu.bar.bazzimport fu; "bar".fu.bazrWr[s rtest_usedInGetattrTest.test_usedInGetattrs" +, -q~~>rc&URS5 g)Nzimport fu; print(fu.bar[1:])rzr[s rtest_usedInSliceTest.test_usedInSlices 23rc&URS5 g)Nz6 import fu if True: print(fu) rzr[s rtest_usedInIfBodyTest.test_usedInIfBody   rc&URS5 g)Nz/ import fu if fu: pass rzr[s rtest_usedInIfConditionalTest.test_usedInIfConditionalrrc&URS5 g)NzH import fu if False: pass elif fu: pass rzr[s rtest_usedInElifConditionalTest.test_usedInElifConditionalrrc&URS5 g)NzJ import fu if False: pass else: print(fu) rzr[s rtest_usedInElseTest.test_usedInElserrc&URS5 g)Nzimport fu; fu.bar()rzr[s rtest_usedInCallTest.test_usedInCalls )*rc&URS5 g)NzC import fu class bar: bar = fu rzr[s rtest_usedInClassTest.test_usedInClassrrc&URS5 g)NzO import fu class bar(object, fu.baz): pass rzr[s rtest_usedInClassBaseTest.test_usedInClassBaserrc&URS5 g)NzR import fu def bleh(): pass print(fu) rzr[s rtest_notUsedInNestedScopeTest.test_notUsedInNestedScope   rc&URS5 g)NzN import fu for bar in range(9): print(fu) rzr[s rtest_usedInForTest.test_usedInForrrc&URS5 g)Nzn import fu for bar in range(10): pass else: print(fu) rzr[s rtest_usedInForElseTest.test_usedInForElse   rcDURS[R5 g)NzH import fu for fu in range(2): pass rXrYImportShadowedByLoopVarr[s 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 Nrr[s 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 Nrr[s rtest_shadowedByForDeepTest.test_shadowedByForDeeps>   & &  (   & &  (rc&URS5 g)NzD import fu def fun(): return fu rzr[s 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.barrzr[s rtest_usedInOperatorsTest.test_usedInOperatorss +, +, +, +, ,- +, ,- () () ,- +, +, +, ,- ,-rc&URS5 g)Nzimport fu; assert fu.barrzr[s rtest_usedInAssertTest.test_usedInAssert#s ./rc&URS5 g)Nzimport fu; fu.bar[1]rzr[s rtest_usedInSubscriptTest.test_usedInSubscript&s *+rcjURS5 URS5 URS5 g)Nzimport fu; fu and Falsezimport fu; fu or Falsezimport fu; not fu.barrzr[s rtest_usedInLogicTest.test_usedInLogic)s) -. ,- +,rc&URS5 g)Nzimport fu; [fu]rzr[s rtest_usedInListTest.test_usedInList.s %&rc&URS5 g)Nzimport fu; (fu,)rzr[s rtest_usedInTupleTest.test_usedInTuple1s &'rc&URS5 gNz@ import fu try: fu except: pass rzr[s rtest_usedInTryTest.test_usedInTry4rrc&URS5 grrzr[s rtest_usedInExceptTest.test_usedInExcept;rrc[R/nUR[R5 UR"S/UQ76 g)NzR import fu try: pass except Exception as fu: pass )rYrvappendUnusedVariablerX)rexpecteds rtest_redefinedByExceptTest.test_redefinedByExceptBs=**+(()     rc&URS5 g)Nz0 import fu raise fu.bar rzr[s rtest_usedInRaiseTest.test_usedInRaiseLrrc&URS5 g)NzC import fu def gen(): yield fu rzr[s rtest_usedInYieldTest.test_usedInYieldRrrcHURS5 URS5 g)Nzimport fu; {fu:None}zimport fu; {1:fu}rzr[s rtest_usedInDictTest.test_usedInDictYs *+ '(rc&URS5 g)NzC import fu def f(bar=fu): pass rzr[s rtest_usedInParameterDefault Test.test_usedInParameterDefault]rrc&URS5 g)Nzimport fu; fu.bar = 1rzr[s rtest_usedInAttributeAssignTest.test_usedInAttributeAssignd +,rc&URS5 g)Nzimport fu; fu.bar(stuff=fu)rzr[s rtest_usedInKeywordArgTest.test_usedInKeywordArggs 12rcHURS5 URS5 g)Nzimport fu; bar=fuzimport fu; n=0; n+=furzr[s rtest_usedInAssignmentTest.test_usedInAssignmentjs '( +,rcHURS5 URS5 g)Nz!import fu; [fu for _ in range(1)]z&import fu; [1 for _ in range(1) if fu]rzr[s rtest_usedInListCompTest.test_usedInListCompns 78 <=rcHURS5 URS5 g)NzA import fu try: pass finally: fu zA import fu try: fu finally: pass rzr[s rtest_usedInTryFinallyTest.test_usedInTryFinallyrs&     rcHURS5 URS5 g)Nz; import fu while 0: fu z2 import fu while fu: pass rzr[s rtest_usedInWhileTest.test_usedInWhiles&     rcbURS[R[R5 g)z\ A 'global' statement shadowing an unused import should not prevent it from being reported. z6 import fu def f(): global fu N)rXrYrZUnusedIndirectAssignmentr[s rtest_usedInGlobalTest.test_usedInGlobals&  ^^Q77 9rcDURS[R5 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() N)rXrYr@r[s rtest_usedAndGlobalTest.test_usedAndGlobals   ' '  )rc&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() Nrzr[s rtest_assignedToGlobalTest.test_assignedToGlobals   rc0SnURSU-5 g)Nzexec("print(1)", fu.bar)z import fu; %srz)r exec_stmts rtest_usedInExecTest.test_usedInExecs.  Oi/0rc&URS5 g)Nzimport fu; lambda: furzr[s rtest_usedInLambdaTest.test_usedInLambdar/rcURS[R[R5 URS5 g)Nzimport fu; lambda fu: fuzimport fu; lambda fu: fu fu()rr[s rtest_shadowedByLambdaTest.test_shadowedByLambdas- .NNA$:$: < 45rc&URS5 g)Nzimport fu; "meow"[::fu]rzr[s rtest_usedInSliceObjTest.test_usedInSliceObjs -.rcbURS[R[R5 g)Nz= def bar(): import fu fu )rXrYrZrr[s rtest_unusedInNestedScopeTest.test_unusedInNestedScopes"  ^^Q__  .rcDURS[R5 g)Nz` class bar: import fu def fun(self): fu rr[s rtest_methodsDontUseClassScope"Test.test_methodsDontUseClassScopes  __  rc&URS5 g)NzX def a(): def b(): fu import fu rzr[s rtest_nestedFunctionsNestScope"Test.test_nestedFunctionsNestScoperrc&URS5 g)Nz def a(): import fu class b: def c(self): print(fu) rzr[s 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 )furk)zfu.*NrXrYImportStarUsedrZrrm startswithrnros 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 rrcrlrerk)z.fu.*from .. import *r1)rlNrfros 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 levelrmN)rXrYImportStarNotPermittedrrmrnros rtest_localImportStarTest.test_localImportStars   % % '   % % ' ++  % %'  #}} QQQQ!!X---rc&URS5 g)z@ If a dotted name is imported and used, no warning is reported. z. import fu.bar fu.bar Nrzr[s rtest_packageImportTest.test_packageImport!s   rcDURS[R5 g)zR If a dotted name is imported and not used, an unused import warning is reported. z import fu.barNrWr[s 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 Nrr[s rtest_duplicateSubmoduleImport"Test.test_duplicateSubmoduleImport1s>   # # %   # #  %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 Nrzr[s 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 Nrzr[s r'test_used_package_with_submodule_import,Test.test_used_package_with_submodule_importO(     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() Nrzr[s 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 rrk)zfu.barN)rXrYrZrrmrn withDoctestlinenoros r)test_unused_package_with_submodule_import.Test.test_unused_package_with_submodule_importosx++ ^^  #}} 8888!!\111$($4$4u||q ;;! rcURS5 URS5 URS5 URS5 g)Nzimport fu; fu = fuzimport fu; fu, bar = fuzimport fu; [fu, bar] = fuzimport fu; fu += furzr[s rtest_assignRHSFirstTest.test_assignRHSFirst|s6 () -. /0 )*rc&URS5 g)Nzp try: import fu except ImportError: import bar as fu fu rzr[s rtest_tryingMultipleImportsTest.test_tryingMultipleImportsrrc&URS5 g)Nz` import fu def a(): fu = 3 return fu fu rzr[s rtest_nonGlobalDoesNotRedefine"Test.test_nonGlobalDoesNotRedefinerrc&URS5 g)Nz; def a(): fu import fu rzr[s rtest_functionsRunLaterTest.test_functionsRunLaterrrcDURS[R5 g)NzG import fu def fu(): fu fu rr[s rtest_functionNamesAreBoundNow"Test.test_functionNamesAreBoundNows   # #  %rc&URS5 g)Nz a = 1; a = 2rzr[s r!test_ignoreNonImportRedefinitions&Test.test_ignoreNonImportRedefinitionss N#rtodoc&URS5 g)NzY try: import fu except ImportError: pass rzr[s 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 Nrzr[s 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 Nrzr[s 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 Nrzr[s 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)rXrYLateFutureImportr[s 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 Nrzr[s rtest_futureImportUsedTest.test_futureImportUsedrr)rzin 3.14+ this is a SyntaxErrorcDURS[R5 g)z0Importing undefined names from __future__ fails.z8 from __future__ import print_statement NrXrYFutureFeatureNotDefinedr[s rtest_futureImportUndefinedTest.test_futureImportUndefined   & & (rcDURS[R5 g)z$Importing '*' from __future__ fails.z* from __future__ import * Nrr[s rtest_futureImportStarTest.test_futureImportStarrrr^N)jr_r`rarbrhrrrwr{r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrr!r$r'r*r-r1r4r7r:r=rArDrGrKrNrQrTrWrZr]r`rirnrrrurxr{r~rrrrrrrrrr rrrrrrr rrrrcr^rrrereis<O6.< / ) ? H ,  ,     %      % 54  $%        !?4    +     ( ((& ."0,- '(    ) -3->    9 ) 1-6 /.  0*<@.& 5 %    <+    %$ &\       !  LG #%EF(G(  LG #%EF(G(rrec\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)rXrYrZrr[s 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"] NrWr[s rtest_ignoredInClass"TestSpecialAll.test_ignoredInClasss  ^^  rcDURS[R5 g)Nz: import bar (__all__,) = ("foo",) rWr[s r'test_ignored_when_not_directly_assigned6TestSpecialAll.test_ignored_when_not_directly_assigned s  ^^ 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",) Nrzr[s rtest_warningSuppressed%TestSpecialAll.test_warningSuppresseds(      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'] NrXrYUndefinedExportr[s 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'] NrXrYrrZr[s 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',) Nrr[s r#test_tuple_concatenation_assignment2TestSpecialAll.test_tuple_concatenation_assignment5rrc&URS5 g)NzF from foo import bar __all__ = [bar.__name__] rzr[s rtest_all_with_attributes'TestSpecialAll.test_all_with_attributes>rrc&URS5 g)Nz= from foo import bar __all__ = [bar] rzr[s rtest_all_with_names"TestSpecialAll.test_all_with_namesDs   rc&URS5 g)Nzs from foo import bar from bar import baz __all__ = [bar.__name__] + [baz.__name__] rzr[s rtest_all_with_attributes_added-TestSpecialAll.test_all_with_attributes_addedKrrc&URS5 g)Nzi from foo import bar from foo import baz __all__ = ['bar', baz.__name__] rzr[s r%test_all_mixed_attributes_and_strings4TestSpecialAll.test_all_mixed_attributes_and_stringsRrrcvURS[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_unboundExportedYsC     ;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)rXrYrgImportStarUsager[s rtest_importStarExported&TestSpecialAll.test_importStarExportedhs9    q00!2C2CQEVEV  XrcbURS[R[R5 g)z8Report unused import when not needed to satisfy __all__.zL from foolib import * a = 1 __all__ = ['a'] N)rXrYrgrZr[s rtest_importStarNotExported)TestSpecialAll.test_importStarNotExportedrs$    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)Nrzr[s rtest_usedInGenExp TestSpecialAll.test_usedInGenExpzs 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))Nrur[s rtest_redefinedByGenExp%TestSpecialAll.test_redefinedByGenExps" 7**ANN <4rrN)sysrpyflakesrrYpyflakes.checkerrrrrr pyflakes.test.harnessr r r rrerr^rrrsI"98X6HX6vF(8F(RIXIr