o 9Di@s|ddlmZddlmZddlmZmZmZm Z m Z ddl m Z m Z mZGddde ZGddde ZGd d d e Zd S) ) version_info)messages)FutureImportation ImportationImportationFromStarImportationSubmoduleImportation)TestCaseskipskipIfc@seZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#S)$TestImportationObjectcCs.tddd}|jdks Jt|dksJdS)Nazimport arsource_statementstrselfbindingrS/var/www/Datamplify/venv/lib/python3.10/site-packages/pyflakes/test/test_imports.pytest_import_basic z'TestImportationObject.test_import_basiccC.tddd}|jdks Jt|dksJdS)Ncr z import a as cza as crrrrrtest_import_asrz$TestImportationObject.test_import_ascCs,tdd}|jdks Jt|dksJdS)Na.bz import a.b)rrrrrrrtest_import_submodule z+TestImportationObject.test_import_submodulecCr)Nrrzimport a.b as ca.b as crrrrrtest_import_submodule_ass z.TestImportationObject.test_import_submodule_ascCr)Nr rzimport a.b as aza.b as arrrrr$test_import_submodule_as_source_name%rz:TestImportationObject.test_import_submodule_as_source_namecC0tdddd}|jdksJt|dksJdS)Nr .zfrom . import az.arrrrrrrtest_importfrom_relative*z.TestImportationObject.test_importfrom_relativecCr!)Nr ..zfrom .. import a..ar#rrrrtest_importfrom_relative_parent/r%z5TestImportationObject.test_importfrom_relative_parentcCr!)Nbr'zfrom ..a import bz..a.br#rrrr$test_importfrom_relative_with_module4r%z:TestImportationObject.test_importfrom_relative_with_modulecC0tdddd}|jdksJt|dksJdS)Nrr'r)zfrom ..a import b as cz ..a.b as cr#rrrr'test_importfrom_relative_with_module_as9r%z=TestImportationObject.test_importfrom_relative_with_module_ascCr!)Nr)r zfrom a import brr#rrrrtest_importfrom_member>r%z,TestImportationObject.test_importfrom_membercCr!)Nrrzfrom a.b import cza.b.cr#rrrr test_importfrom_submodule_memberCr%z6TestImportationObject.test_importfrom_submodule_membercCr+)Nrr r)zfrom a import b as crr#rrrrtest_importfrom_member_asHr%z/TestImportationObject.test_importfrom_member_ascCr+)Ndrrzfrom a.b import c as dz a.b.c as dr#rrrr#test_importfrom_submodule_member_asMr%z9TestImportationObject.test_importfrom_submodule_member_ascC,tdd}|jdks Jt|dksJdS)Nrzfrom a.b import *za.b.*rrrrrrrtest_importfrom_starRrz*TestImportationObject.test_importfrom_starcCr2)Nz.bzfrom .b import *z.b.*r3rrrrtest_importfrom_star_relativeWrz3TestImportationObject.test_importfrom_star_relativecCs.tddd}|jdks Jt|dksJdS)Nprint_functionz%from __future__ import print_functionz__future__.print_function)rrrrrrrtest_importfrom_future\rz,TestImportationObject.test_importfrom_futurecC|dtjdS)zm The magic underscore var should be reported as unused when used as an import alias. zimport fu as _Nflakesm UnusedImportrrrrtest_unusedImport_underscoreaz2TestImportationObject.test_unusedImport_underscoreN)__name__ __module__ __qualname__rrrrr r$r(r*r,r-r.r/r1r4r5r7r>rrrrr s$ r c@s@eZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAdBZ#dCdDZ$dEdFZ%dGdHZ&dIdJZ'dKdLZ(dMdNZ)dOdPZ*dQdRZ+dSdTZ,dUdVZ-dWdXZ.dYdZZ/d[d\Z0d]d^Z1d_d`Z2dadbZ3dcddZ4dedfZ5dgdhZ6didjZ7dkdlZ8dmdnZ9dodpZ:dqdrZ;dsdtZdydzZ?d{d|Z@d}d~ZAddZBddZCddZDddZEddZFddZGddZHddZIddZJddZKddZLddZMddZNddZOddZPddZQddZRddZSddZTddZUddZVddZWddZXddZYddZZddZ[ddZ\e]dddZ^ddZ_ddZ`ddZaddZbddZcedeedkdÃddńZfedeedkdÃddDŽZgdS)TestcCs(|dtjtj|dtjtjdS)Nzimport fu, barzfrom baz import fu, barr9r=rrrtest_unusedImportkszTest.test_unusedImportcCs|dtj|dtj|dtj|dtj|dtj|dtj|dtj|dtj|d tj|dtj}|jd }|jd ksRJ|jd ksYJ|dtj}|jd }|jd kslJ|jd kssJdS)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)r:r;r<rmessage message_argsrcheckererrorrrrtest_unusedImport_relativeos"  zTest.test_unusedImport_relativecCs(|dtjtj|dtjtjdS)Nzimport fu as FU, bar as FUz#from moo import fu as FU, bar as FUr:r;RedefinedWhileUnusedr<r=rrrtest_aliasedImports zTest.test_aliasedImportcCs"|d|d|ddS)z5Imported aliases can shadow the source of the import.zfrom moo import fu as moo; moozimport fu as fu; fuzimport fu.bar as fu; fuNr:r=rrrtest_aliasedImportShadowModules  z#Test.test_aliasedImportShadowModulecC"|d|d|ddS)Nzimport fu; print(fu)zfrom baz import fu; print(fu)zimport fu; del furPr=rrrtest_usedImport  zTest.test_usedImportcC,|d|d|d|ddS)Nzfrom . import fu; assert fuzfrom .bar import fu; assert fuzfrom .. import fu; assert fuz'from ..bar import fu as baz; assert bazrPr=rrrtest_usedImport_relative   zTest.test_usedImport_relativecCs.|dtj|dtj|dtjdS)Nzimport fu; fu = 3zimport fu; fu, bar = 3zimport fu; [fu, bar] = 3r:r;rNr=rrrtest_redefinedWhileUnusedszTest.test_redefinedWhileUnusedcCr8)ze 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.pathNrXr=rrrtest_redefinedIfzTest.test_redefinedIfcC|ddS)zl 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.pathNrPr=rrrtest_redefinedIfElsezTest.test_redefinedIfElsecCr8)za Test that importing a module twice in a try block does raise a warning. zj try: import os import os except: pass os.pathNrXr=rrrtest_redefinedTryszTest.test_redefinedTrycCr\)zp 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.pathNrPr=rrrtest_redefinedTryExceptr^zTest.test_redefinedTryExceptcCr\)z~ 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.pathNrPr=rrrtest_redefinedTryNestedr^zTest.test_redefinedTryNestedcC|ddS)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) rPr=rrrtest_redefinedTryExceptMultiz!Test.test_redefinedTryExceptMulticC|dtjdS)Nz try: from aa import mixer except ImportError: pass else: from bb import mixer mixer(123) rXr=rrrtest_redefinedTryElseszTest.test_redefinedTryElsecCrb)Nz try: import funca except ImportError: from bb import funca from bb import funcb else: from bbb import funcb print(funca, funcb) rPr=rrrtest_redefinedTryExceptElserdz Test.test_redefinedTryExceptElsecCrb)Nz try: from aa import a except ImportError: from bb import a finally: a = 42 print(a) rPr=rrrtest_redefinedTryExceptFinallyrdz#Test.test_redefinedTryExceptFinallycCrb)Nz try: import b except ImportError: b = Ellipsis from bb import a else: from aa import a finally: a = 42 print(a, b) rPr=rrr"test_redefinedTryExceptElseFinallyrdz'Test.test_redefinedTryExceptElseFinallycCre)Nz> import fu def fu(): pass rXr=rrrtest_redefinedByFunctionzTest.test_redefinedByFunctioncC|dtjtjdS)r Test that shadowing a global name with a nested function definition generates a warning. zx import fu def bar(): def baz(): def fu(): pass NrMr=rrrtest_redefinedInNestedFunction&sz#Test.test_redefinedInNestedFunctioncCs|dtjtjtjtjdS)rmz import fu def bar(): import fu def baz(): def fu(): pass NrMr=rrr#test_redefinedInNestedFunctionTwice3sz(Test.test_redefinedInNestedFunctionTwicecCr\)z 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() NrPr=rrrtest_redefinedButUsedLaterCr^zTest.test_redefinedButUsedLatercCre)Nz> import fu class fu: pass rXr=rrrtest_redefinedByClassUrkzTest.test_redefinedByClasscCr\)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 NrPr=rrrtest_redefinedBySubclass\r^zTest.test_redefinedBySubclasscCr\)zi Test that shadowing a global with a class attribute does not produce a warning. zS import fu class bar: fu = 1 print(fu) NrPr=rrrtest_redefinedInClassgr^zTest.test_redefinedInClasscCs|d|dtjdS)zN Test that import within class is a locally scoped attribute. z2 class bar: import fu z> class bar: import fu fu Nr:r; UndefinedNamer=rrrtest_importInClassss zTest.test_importInClasscCrb)NzD import fu def fun(): print(fu) rPr=rrrtest_usedInFunctionrdzTest.test_usedInFunctioncC |dtjtj|ddS)NzF import fu def fun(fu): print(fu) zX import fu def fun(fu): print(fu) print(fu) r:r;r<rNr=rrrtest_shadowedByParameterszTest.test_shadowedByParametercCrb)Nz fu = NonerPr=rrrtest_newAssignmentrdzTest.test_newAssignmentcCs|d|dtjdS)Nzimport fu; fu.bar.bazzimport fu; "bar".fu.bazr9r=rrrtest_usedInGetattrs zTest.test_usedInGetattrcCrb)Nzimport fu; print(fu.bar[1:])rPr=rrrtest_usedInSlicerdzTest.test_usedInSlicecCrb)Nz6 import fu if True: print(fu) rPr=rrrtest_usedInIfBodyrdzTest.test_usedInIfBodycCrb)Nz/ import fu if fu: pass rPr=rrrtest_usedInIfConditionalrdzTest.test_usedInIfConditionalcCrb)NzH import fu if False: pass elif fu: pass rPr=rrrtest_usedInElifConditionalrdzTest.test_usedInElifConditionalcCrb)NzJ import fu if False: pass else: print(fu) rPr=rrrtest_usedInElserdzTest.test_usedInElsecCrb)Nzimport fu; fu.bar()rPr=rrrtest_usedInCallrdzTest.test_usedInCallcCrb)NzC import fu class bar: bar = fu rPr=rrrtest_usedInClassrdzTest.test_usedInClasscCrb)NzO import fu class bar(object, fu.baz): pass rPr=rrrtest_usedInClassBaserdzTest.test_usedInClassBasecCrb)NzR import fu def bleh(): pass print(fu) rPr=rrrtest_notUsedInNestedScoperdzTest.test_notUsedInNestedScopecCrb)NzN import fu for bar in range(9): print(fu) rPr=rrrtest_usedInForrdzTest.test_usedInForcCrb)Nzn import fu for bar in range(10): pass else: print(fu) rPr=rrrtest_usedInForElserdzTest.test_usedInForElsecCre)NzH import fu for fu in range(2): pass r:r;ImportShadowedByLoopVarr=rrrtest_redefinedByForrkzTest.test_redefinedByForcCr8)zi Test that shadowing a global name with a for loop variable generates a warning. zS import fu fu.bar() for fu in (): pass Nrr=rrrtest_shadowedByForr[zTest.test_shadowedByForcC |dtj|dtjdS)z 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=rrrtest_shadowedByForDeeps zTest.test_shadowedByForDeepcCrb)NzD import fu def fun(): return fu rPr=rrrtest_usedInReturn rdzTest.test_usedInReturncCs|d|d|d|d|d|d|d|d|d |d |d |d |d |d|ddS)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.barrPr=rrrtest_usedInOperatorss              zTest.test_usedInOperatorscCrb)Nzimport fu; assert fu.barrPr=rrrtest_usedInAssert#rdzTest.test_usedInAssertcCrb)Nzimport fu; fu.bar[1]rPr=rrrtest_usedInSubscript&rdzTest.test_usedInSubscriptcCrR)Nzimport fu; fu and Falsezimport fu; fu or Falsezimport fu; not fu.barrPr=rrrtest_usedInLogic)rTzTest.test_usedInLogiccCrb)Nzimport fu; [fu]rPr=rrrtest_usedInList.rdzTest.test_usedInListcCrb)Nzimport fu; (fu,)rPr=rrrtest_usedInTuple1rdzTest.test_usedInTuplecCrbNz@ import fu try: fu except: pass rPr=rrrtest_usedInTry4rdzTest.test_usedInTrycCrbrrPr=rrrtest_usedInExcept;rdzTest.test_usedInExceptcCs*tjg}|tj|jdg|RdS)NzR import fu try: pass except Exception as fu: pass )r;rNappendUnusedVariabler:)rexpectedrrrtest_redefinedByExceptBs   zTest.test_redefinedByExceptcCrb)Nz0 import fu raise fu.bar rPr=rrrtest_usedInRaiseLrdzTest.test_usedInRaisecCrb)NzC import fu def gen(): yield fu rPr=rrrtest_usedInYieldRrdzTest.test_usedInYieldcC|d|ddS)Nzimport fu; {fu:None}zimport fu; {1:fu}rPr=rrrtest_usedInDictY zTest.test_usedInDictcCrb)NzC import fu def f(bar=fu): pass rPr=rrrtest_usedInParameterDefault]rdz Test.test_usedInParameterDefaultcCrb)Nzimport fu; fu.bar = 1rPr=rrrtest_usedInAttributeAssigndrdzTest.test_usedInAttributeAssigncCrb)Nzimport fu; fu.bar(stuff=fu)rPr=rrrtest_usedInKeywordArggrdzTest.test_usedInKeywordArgcCr)Nzimport fu; bar=fuzimport fu; n=0; n+=furPr=rrrtest_usedInAssignmentjrzTest.test_usedInAssignmentcCr)Nz!import fu; [fu for _ in range(1)]z&import fu; [1 for _ in range(1) if fu]rPr=rrrtest_usedInListCompnrzTest.test_usedInListCompcCr)NzA import fu try: pass finally: fu zA import fu try: fu finally: pass rPr=rrrtest_usedInTryFinallyr zTest.test_usedInTryFinallycCr)Nz; import fu while 0: fu z2 import fu while fu: pass rPr=rrrtest_usedInWhilerzTest.test_usedInWhilecCrl)zt A 'global' statement shadowing an unused import should not prevent it from being reported. z6 import fu def f(): global fu N)r:r;r<UnusedIndirectAssignmentr=rrrtest_usedInGlobalszTest.test_usedInGlobalcCr8)zt 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)r:r;rr=rrrtest_usedAndGlobalszTest.test_usedAndGlobalcCr\)zn 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() NrPr=rrrtest_assignedToGlobalr^zTest.test_assignedToGlobalcCsd}|d|dS)Nzexec("print(1)", fu.bar)z import fu; %srP)r exec_stmtrrrtest_usedInExecszTest.test_usedInExeccCrb)Nzimport fu; lambda: furPr=rrrtest_usedInLambdardzTest.test_usedInLambdacCrx)Nzimport fu; lambda fu: fuzimport fu; lambda fu: fu fu()ryr=rrrtest_shadowedByLambdaszTest.test_shadowedByLambdacCrb)Nzimport fu; "meow"[::fu]rPr=rrrtest_usedInSliceObjrdzTest.test_usedInSliceObjcCs|dtjtjdS)Nz= def bar(): import fu fu )r:r;r<rur=rrrtest_unusedInNestedScopeszTest.test_unusedInNestedScopecCre)Nz` class bar: import fu def fun(self): fu rtr=rrrtest_methodsDontUseClassScopez"Test.test_methodsDontUseClassScopecCrb)NzX def a(): def b(): fu import fu rPr=rrrtest_nestedFunctionsNestScoperdz"Test.test_nestedFunctionsNestScopecCrb)Nz def a(): import fu class b: def c(self): print(fu) rPr=rrr test_nestedClassAndFunctionScoperdz%Test.test_nestedClassAndFunctionScopecCs|dtjtj|dtjtj|dtjtj}|jd}|jds(J|jdks/J|jd}|jdks;J|jdksBJd S) 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 )furE)zfu.*Nr:r;ImportStarUsedr<rrG startswithrHrIrrrtest_importStars  zTest.test_importStarcCs|dtjtj|dtjtj|dtjtj}|jd}|jds(J|jdks/J|jd}|jdks;J|jdksBJ|d tjtj}|jd}|jdsXJ|jd ks_J|jd}|jdkskJ|jd ksrJd S) z3Use of import * from a relative import is reported.zfrom .fu import *zU try: from .fu import * except: pass rrrFrrE)z.fu.*from .. import *r&)rNrrIrrrtest_importStar_relatives,    zTest.test_importStar_relativecCsT|dtj|dtj|dtj}|jd}|jdks!J|jdks(JdS)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 levelrN)r:r;ImportStarNotPermittedrrGrHrIrrrtest_localImportStars zTest.test_localImportStarcCr\)zP If a dotted name is imported and used, no warning is reported. z. import fu.bar fu.bar NrPr=rrrtest_packageImport!zTest.test_packageImportcCr8)zj If a dotted name is imported and not used, an unused import warning is reported. z import fu.barNr9r=rrrtest_unusedPackageImport*r?zTest.test_unusedPackageImportcCr)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 NrXr=rrrtest_duplicateSubmoduleImport1s z"Test.test_duplicateSubmoduleImportcC|d|ddS)z 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 NrPr=rrrtest_differentSubmoduleImport@ z"Test.test_differentSubmoduleImportcCr)zC Usage of package marks submodule imports as used. z> import fu import fu.bar fu.x z> import fu.bar import fu fu.x NrPr=rrr'test_used_package_with_submodule_importO z,Test.test_used_package_with_submodule_importcCr)zL 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() NrPr=rrr0test_used_package_with_submodule_import_of_alias_rz5Test.test_used_package_with_submodule_import_of_aliascCsP|dtj}|jd}|jdksJ|jdksJ|jr$|jdks&JdSdS)zR When a package and its submodule are imported, only report once. z1 import fu import fu.bar rrE)zfu.barN)r:r;r<rrGrH withDoctestlinenorIrrr)test_unused_package_with_submodule_importos z.Test.test_unused_package_with_submodule_importcCrU)Nzimport fu; fu = fuzimport fu; fu, bar = fuzimport fu; [fu, bar] = fuzimport fu; fu += furPr=rrrtest_assignRHSFirst|rWzTest.test_assignRHSFirstcCrb)Nzp try: import fu except ImportError: import bar as fu fu rPr=rrrtest_tryingMultipleImportsrdzTest.test_tryingMultipleImportscCrb)Nz` import fu def a(): fu = 3 return fu fu rPr=rrrtest_nonGlobalDoesNotRedefinerdz"Test.test_nonGlobalDoesNotRedefinecCrb)Nz; def a(): fu import fu rPr=rrrtest_functionsRunLaterrdzTest.test_functionsRunLatercCre)NzG import fu def fu(): fu fu rXr=rrrtest_functionNamesAreBoundNowrz"Test.test_functionNamesAreBoundNowcCrb)Nz a = 1; a = 2rPr=rrr!test_ignoreNonImportRedefinitionsrdz&Test.test_ignoreNonImportRedefinitionstodocCrb)NzY try: import fu except ImportError: pass rPr=rrrtest_importingForImportErrorz!Test.test_importingForImportErrorcCr\)z0Imports in class scope can be used through self.zf class c: import i def __init__(self): self.i NrPr=rrrtest_importedInClassrzTest.test_importedInClasscCr\)zW 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 NrPr=rrr!test_importUsedInMethodDefinitionrz&Test.test_importUsedInMethodDefinitioncCr)z__future__ is special.zfrom __future__ import divisionze "docstring is allowed before future import" from __future__ import division NrPr=rrrtest_futureImports zTest.test_futureImportcCr)zD __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)r:r;LateFutureImportr=rrrtest_futureImportFirsts zTest.test_futureImportFirstcCr\)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 NrPr=rrrtest_futureImportUsedrzTest.test_futureImportUsed)rzin 3.14+ this is a SyntaxErrorcCr8)z0Importing undefined names from __future__ fails.z8 from __future__ import print_statement Nr:r;FutureFeatureNotDefinedr=rrrtest_futureImportUndefinedzTest.test_futureImportUndefinedcCr8)z$Importing '*' from __future__ fails.z* from __future__ import * Nrr=rrrtest_futureImportStarrzTest.test_futureImportStarN)hr@rArBrDrLrOrQrSrVrYrZr]r_r`rarcrfrgrhrirjrnrorprqrrrsrvrwrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr rrrrrrrrCis                              rCc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&S)'TestSpecialAllzH Tests for suppression of unused import warnings by C{__all__}. cCrl)zp An C{__all__} definition does not suppress unused import warnings in a function scope. zQ def foo(): import bar __all__ = ["bar"] N)r:r;r<rr=rrrtest_ignoredInFunctionsz%TestSpecialAll.test_ignoredInFunctioncCr8)z_ An C{__all__} definition in a class does not suppress unused import warnings. zM import bar class foo: __all__ = ["bar"] Nr9r=rrrtest_ignoredInClasssz"TestSpecialAll.test_ignoredInClasscCre)Nz: import bar (__all__,) = ("foo",) r9r=rrr'test_ignored_when_not_directly_assigned sz6TestSpecialAll.test_ignored_when_not_directly_assignedcCr)zn 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",) NrPr=rrrtest_warningSuppressedrz%TestSpecialAll.test_warningSuppressedcCs|dtjtjdS)zC The C{__all__} variable is defined incrementally. z import a import c __all__ = ['a'] __all__ += ['b'] if 1 < 3: __all__ += ['c', 'd'] Nr:r;UndefinedExportr=rrrtest_augmentedAssignmentsz'TestSpecialAll.test_augmentedAssignmentcC|dtjtjtjtjdS)zP The C{__all__} variable is defined through list concatenation. zD import sys __all__ = ['a'] + ['b'] + ['c'] Nr:r;rr<r=rrr"test_list_concatenation_assignment,z1TestSpecialAll.test_list_concatenation_assignmentcCr)zQ The C{__all__} variable is defined through tuple concatenation. zG import sys __all__ = ('a',) + ('b',) + ('c',) Nrr=rrr#test_tuple_concatenation_assignment5rz2TestSpecialAll.test_tuple_concatenation_assignmentcCrb)NzF from foo import bar __all__ = [bar.__name__] rPr=rrrtest_all_with_attributes>rdz'TestSpecialAll.test_all_with_attributescCrb)Nz= from foo import bar __all__ = [bar] rPr=rrrtest_all_with_namesDrz"TestSpecialAll.test_all_with_namescCrb)Nzs from foo import bar from bar import baz __all__ = [bar.__name__] + [baz.__name__] rPr=rrrtest_all_with_attributes_addedKrdz-TestSpecialAll.test_all_with_attributes_addedcCrb)Nzi from foo import bar from foo import baz __all__ = ['bar', baz.__name__] rPr=rrr%test_all_mixed_attributes_and_stringsRrdz4TestSpecialAll.test_all_mixed_attributes_and_stringscCs*|dtjdD] }|jd|dq dS)zY 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)rrrrrtest_unboundExportedYsz#TestSpecialAll.test_unboundExportedcCs|dtjtjtjtjdS)z6 Report undefined if import * is used zT from math import * __all__ = ['sin', 'cos'] csc(1) N)r:r;rImportStarUsager=rrrtest_importStarExportedhsz&TestSpecialAll.test_importStarExportedcCrl)z8Report unused import when not needed to satisfy __all__.zL from foolib import * a = 1 __all__ = ['a'] N)r:r;rr<r=rrrtest_importStarNotExportedrsz)TestSpecialAll.test_importStarNotExportedcCr)zR 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)NrPr=rrrtest_usedInGenExpzs z TestSpecialAll.test_usedInGenExpcCrl)z 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))NrMr=rrrtest_redefinedByGenExpsz%TestSpecialAll.test_redefinedByGenExpcC&|d|d|dtjdS)z Using a global name in a decorator statement results in no warnings, but using an undefined name in a decorator statement results in an undefined name warning. zm from interior import decorate @decorate def f(): return "hello" zv from interior import decorate @decorate('value') def f(): return "hello" zG @decorate def f(): return "hello" Nrtr=rrrtest_usedAsDecorator  z#TestSpecialAll.test_usedAsDecoratorcCr)z Using an imported name as a class decorator results in no warnings, but using an undefined name as a class decorator results in an undefined name warning. ze from interior import decorate @decorate class foo: pass zl from interior import decorate @decorate("foo") class bar: pass z? @decorate class foo: pass Nrtr=rrrtest_usedAsClassDecoratorrz(TestSpecialAll.test_usedAsClassDecoratorN)r@rArB__doc__rrrrrrrrrrrrrrrrrrrrrrrs(       rN)sysrpyflakesrr;pyflakes.checkerrrrrrpyflakes.test.harnessr r r r rCrrrrrs [