o h@slddlmZddlmZmZmZmZmZddl m Z m Z Gddde Z Gddde Z Gdd d e Zd S) )messages)FutureImportation ImportationImportationFromStarImportationSubmoduleImportation)TestCaseskipc@seZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#S)$TestImportationObjectcCs.tddd}|jdks Jt|dksJdS)Nazimport arsource_statementstrselfbindingrP/var/www/html/ai/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 cr rrrrtest_import_asrz$TestImportationObject.test_import_ascCs,tdd}|jdks Jt|dksJdS)Na.bz import a.b)rr rrrrrtest_import_submodule z+TestImportationObject.test_import_submodulecCr)Nrrzimport a.b as ca.b as cr rrrrtest_import_submodule_ass z.TestImportationObject.test_import_submodule_ascCr)Nr rzimport a.b as aza.b as ar rrrr$test_import_submodule_as_source_name#rz:TestImportationObject.test_import_submodule_as_source_namecC0tdddd}|jdksJt|dksJdS)Nr .zfrom . import az.arr rrrrrtest_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_module2r#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_as7r#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_memberAr#z6TestImportationObject.test_importfrom_submodule_membercCr))Nrr r'zfrom a import b as crr!rrrrtest_importfrom_member_asFr#z/TestImportationObject.test_importfrom_member_ascCr))Ndrrzfrom a.b import c as dz a.b.c as dr!rrrr#test_importfrom_submodule_member_asKr#z9TestImportationObject.test_importfrom_submodule_member_ascC,tdd}|jdks Jt|dksJdS)Nrzfrom a.b import *za.b.*rr rrrrrtest_importfrom_starPrz*TestImportationObject.test_importfrom_starcCr0)Nz.bzfrom .b import *z.b.*r1rrrrtest_importfrom_star_relativeUrz3TestImportationObject.test_importfrom_star_relativecCs.tddd}|jdks Jt|dksJdS)Nprint_functionz%from __future__ import print_functionz__future__.print_function)rr rrrrrtest_importfrom_futureZrz,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_underscore_z2TestImportationObject.test_unusedImport_underscoreN)__name__ __module__ __qualname__rrrrrr"r&r(r*r+r,r-r/r2r3r5r<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`ddZaddZbddZcddÄZdddńZedS)TestcCs(|dtjtj|dtjtjdS)Nzimport fu, barzfrom baz import fu, barr7r;rrrtest_unusedImportiszTest.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)r8r9r:rmessage message_argsrcheckererrorrrrtest_unusedImport_relativems"  zTest.test_unusedImport_relativecCs(|dtjtj|dtjtjdS)Nzimport fu as FU, bar as FUz#from moo import fu as FU, bar as FUr8r9RedefinedWhileUnusedr: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; fuNr8r;rrrtest_aliasedImportShadowModules  z#Test.test_aliasedImportShadowModulecC"|d|d|ddS)Nzimport fu; print(fu)zfrom baz import fu; print(fu)zimport fu; del furNr;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 bazrNr;rrrtest_usedImport_relative   zTest.test_usedImport_relativecCs.|dtj|dtj|dtjdS)Nzimport fu; fu = 3zimport fu; fu, bar = 3zimport fu; [fu, bar] = 3r8r9rLr;rrrtest_redefinedWhileUnusedszTest.test_redefinedWhileUnusedcCr6)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.pathNrVr;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.pathNrNr;rrrtest_redefinedIfElsezTest.test_redefinedIfElsecCr6)za Test that importing a module twice in a try block does raise a warning. zj try: import os import os except: pass os.pathNrVr;rrrtest_redefinedTryszTest.test_redefinedTrycCrZ)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.pathNrNr;rrrtest_redefinedTryExceptr\zTest.test_redefinedTryExceptcCrZ)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.pathNrNr;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) rNr;rrrtest_redefinedTryExceptMultiz!Test.test_redefinedTryExceptMulticC|dtjdS)Nz try: from aa import mixer except ImportError: pass else: from bb import mixer mixer(123) rVr;rrrtest_redefinedTryElseszTest.test_redefinedTryElsecCr`)Nz try: import funca except ImportError: from bb import funca from bb import funcb else: from bbb import funcb print(funca, funcb) rNr;rrrtest_redefinedTryExceptElserbz Test.test_redefinedTryExceptElsecCr`)Nz try: from aa import a except ImportError: from bb import a finally: a = 42 print(a) rNr;rrrtest_redefinedTryExceptFinallyrbz#Test.test_redefinedTryExceptFinallycCr`)Nz try: import b except ImportError: b = Ellipsis from bb import a else: from aa import a finally: a = 42 print(a, b) rNr;rrr"test_redefinedTryExceptElseFinallyrbz'Test.test_redefinedTryExceptElseFinallycCrc)Nz> import fu def fu(): pass rVr;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 NrKr;rrrtest_redefinedInNestedFunction$sz#Test.test_redefinedInNestedFunctioncCs|dtjtjtjtjdS)rkz import fu def bar(): import fu def baz(): def fu(): pass NrKr;rrr#test_redefinedInNestedFunctionTwice1sz(Test.test_redefinedInNestedFunctionTwicecCrZ)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() NrNr;rrrtest_redefinedButUsedLaterAr\zTest.test_redefinedButUsedLatercCrc)Nz> import fu class fu: pass rVr;rrrtest_redefinedByClassSrizTest.test_redefinedByClasscCrZ)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 NrNr;rrrtest_redefinedBySubclassZr\zTest.test_redefinedBySubclasscCrZ)zi Test that shadowing a global with a class attribute does not produce a warning. zS import fu class bar: fu = 1 print(fu) NrNr;rrrtest_redefinedInClasser\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 Nr8r9 UndefinedNamer;rrrtest_importInClassqs zTest.test_importInClasscCr`)NzD import fu def fun(): print(fu) rNr;rrrtest_usedInFunctionrbzTest.test_usedInFunctioncC |dtjtj|ddS)NzF import fu def fun(fu): print(fu) zX import fu def fun(fu): print(fu) print(fu) r8r9r:rLr;rrrtest_shadowedByParameterszTest.test_shadowedByParametercCr`)Nz fu = NonerNr;rrrtest_newAssignmentrbzTest.test_newAssignmentcCs|d|dtjdS)Nzimport fu; fu.bar.bazzimport fu; "bar".fu.bazr7r;rrrtest_usedInGetattrs zTest.test_usedInGetattrcCr`)Nzimport fu; print(fu.bar[1:])rNr;rrrtest_usedInSlicerbzTest.test_usedInSlicecCr`)Nz6 import fu if True: print(fu) rNr;rrrtest_usedInIfBodyrbzTest.test_usedInIfBodycCr`)Nz/ import fu if fu: pass rNr;rrrtest_usedInIfConditionalrbzTest.test_usedInIfConditionalcCr`)NzH import fu if False: pass elif fu: pass rNr;rrrtest_usedInElifConditionalrbzTest.test_usedInElifConditionalcCr`)NzJ import fu if False: pass else: print(fu) rNr;rrrtest_usedInElserbzTest.test_usedInElsecCr`)Nzimport fu; fu.bar()rNr;rrrtest_usedInCallrbzTest.test_usedInCallcCr`)NzC import fu class bar: bar = fu rNr;rrrtest_usedInClassrbzTest.test_usedInClasscCr`)NzO import fu class bar(object, fu.baz): pass rNr;rrrtest_usedInClassBaserbzTest.test_usedInClassBasecCr`)NzR import fu def bleh(): pass print(fu) rNr;rrrtest_notUsedInNestedScoperbzTest.test_notUsedInNestedScopecCr`)NzN import fu for bar in range(9): print(fu) rNr;rrrtest_usedInForrbzTest.test_usedInForcCr`)Nzn import fu for bar in range(10): pass else: print(fu) rNr;rrrtest_usedInForElserbzTest.test_usedInForElsecCrc)NzH import fu for fu in range(2): pass r8r9ImportShadowedByLoopVarr;rrrtest_redefinedByForrizTest.test_redefinedByForcCr6)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_shadowedByForrYzTest.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_shadowedByForDeepcCr`)NzD import fu def fun(): return fu rNr;rrrtest_usedInReturn rbzTest.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.barrNr;rrrtest_usedInOperatorss              zTest.test_usedInOperatorscCr`)Nzimport fu; assert fu.barrNr;rrrtest_usedInAssert!rbzTest.test_usedInAssertcCr`)Nzimport fu; fu.bar[1]rNr;rrrtest_usedInSubscript$rbzTest.test_usedInSubscriptcCrP)Nzimport fu; fu and Falsezimport fu; fu or Falsezimport fu; not fu.barrNr;rrrtest_usedInLogic'rRzTest.test_usedInLogiccCr`)Nzimport fu; [fu]rNr;rrrtest_usedInList,rbzTest.test_usedInListcCr`)Nzimport fu; (fu,)rNr;rrrtest_usedInTuple/rbzTest.test_usedInTuplecCr`Nz@ import fu try: fu except: pass rNr;rrrtest_usedInTry2rbzTest.test_usedInTrycCr`rrNr;rrrtest_usedInExcept9rbzTest.test_usedInExceptcCs*tjg}|tj|jdg|RdS)NzR import fu try: pass except Exception as fu: pass )r9rLappendUnusedVariabler8)rexpectedrrrtest_redefinedByExcept@s   zTest.test_redefinedByExceptcCr`)Nz0 import fu raise fu.bar rNr;rrrtest_usedInRaiseJrbzTest.test_usedInRaisecCr`)NzC import fu def gen(): yield fu rNr;rrrtest_usedInYieldPrbzTest.test_usedInYieldcC|d|ddS)Nzimport fu; {fu:None}zimport fu; {1:fu}rNr;rrrtest_usedInDictW zTest.test_usedInDictcCr`)NzC import fu def f(bar=fu): pass rNr;rrrtest_usedInParameterDefault[rbz Test.test_usedInParameterDefaultcCr`)Nzimport fu; fu.bar = 1rNr;rrrtest_usedInAttributeAssignbrbzTest.test_usedInAttributeAssigncCr`)Nzimport fu; fu.bar(stuff=fu)rNr;rrrtest_usedInKeywordArgerbzTest.test_usedInKeywordArgcCr)Nzimport fu; bar=fuzimport fu; n=0; n+=furNr;rrrtest_usedInAssignmenthrzTest.test_usedInAssignmentcCr)Nz!import fu; [fu for _ in range(1)]z&import fu; [1 for _ in range(1) if fu]rNr;rrrtest_usedInListComplrzTest.test_usedInListCompcCr)NzA import fu try: pass finally: fu zA import fu try: fu finally: pass rNr;rrrtest_usedInTryFinallyp zTest.test_usedInTryFinallycCr)Nz; import fu while 0: fu z2 import fu while fu: pass rNr;rrrtest_usedInWhile}rzTest.test_usedInWhilecCr6)zt A 'global' statement shadowing an unused import should not prevent it from being reported. z6 import fu def f(): global fu Nr7r;rrrtest_usedInGlobalszTest.test_usedInGlobalcCrZ)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() NrNr;rrrtest_usedAndGlobalr\zTest.test_usedAndGlobalcCrZ)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() NrNr;rrrtest_assignedToGlobalr\zTest.test_assignedToGlobalcCsd}|d|dS)Nzexec("print(1)", fu.bar)z import fu; %srN)r exec_stmtrrrtest_usedInExecszTest.test_usedInExeccCr`)Nzimport fu; lambda: furNr;rrrtest_usedInLambdarbzTest.test_usedInLambdacCrv)Nzimport fu; lambda fu: fuzimport fu; lambda fu: fu fu()rwr;rrrtest_shadowedByLambdaszTest.test_shadowedByLambdacCr`)Nzimport fu; "meow"[::fu]rNr;rrrtest_usedInSliceObjrbzTest.test_usedInSliceObjcCs|dtjtjdS)Nz= def bar(): import fu fu )r8r9r:rsr;rrrtest_unusedInNestedScopeszTest.test_unusedInNestedScopecCrc)Nz` class bar: import fu def fun(self): fu rrr;rrrtest_methodsDontUseClassScopez"Test.test_methodsDontUseClassScopecCr`)NzX def a(): def b(): fu import fu rNr;rrrtest_nestedFunctionsNestScoperbz"Test.test_nestedFunctionsNestScopecCr`)Nz def a(): import fu class b: def c(self): print(fu) rNr;rrr test_nestedClassAndFunctionScoperbz%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 )furC)zfu.*Nr8r9ImportStarUsedr:rrE startswithrFrGrrrtest_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 rrrDrrC)z.fu.*from .. import *r$)rNrrGrrrtest_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)r8r9ImportStarNotPermittedrrErFrGrrrtest_localImportStar s zTest.test_localImportStarcCrZ)zP If a dotted name is imported and used, no warning is reported. z. import fu.bar fu.bar NrNr;rrrtest_packageImportzTest.test_packageImportcCr6)zj If a dotted name is imported and not used, an unused import warning is reported. z import fu.barNr7r;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 NrVr;rrrtest_duplicateSubmoduleImport/s 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 NrNr;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 NrNr;rrr'test_used_package_with_submodule_importM 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() NrNr;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 rrC)zfu.barN)r8r9r:rrErF withDoctestlinenorGrrr)test_unused_package_with_submodule_importms z.Test.test_unused_package_with_submodule_importcCrS)Nzimport fu; fu = fuzimport fu; fu, bar = fuzimport fu; [fu, bar] = fuzimport fu; fu += furNr;rrrtest_assignRHSFirstzrUzTest.test_assignRHSFirstcCr`)Nzp try: import fu except ImportError: import bar as fu fu rNr;rrrtest_tryingMultipleImportsrbzTest.test_tryingMultipleImportscCr`)Nz` import fu def a(): fu = 3 return fu fu rNr;rrrtest_nonGlobalDoesNotRedefinerbz"Test.test_nonGlobalDoesNotRedefinecCr`)Nz; def a(): fu import fu rNr;rrrtest_functionsRunLaterrbzTest.test_functionsRunLatercCrc)NzG import fu def fu(): fu fu rVr;rrrtest_functionNamesAreBoundNowrz"Test.test_functionNamesAreBoundNowcCr`)Nz a = 1; a = 2rNr;rrr!test_ignoreNonImportRedefinitionsrbz&Test.test_ignoreNonImportRedefinitionstodocCr`)NzY try: import fu except ImportError: pass rNr;rrrtest_importingForImportErrorz!Test.test_importingForImportErrorcCrZ)z0Imports in class scope can be used through self.zf class c: import i def __init__(self): self.i NrNr;rrrtest_importedInClassrzTest.test_importedInClasscCrZ)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 NrNr;rrr!test_importUsedInMethodDefinitionrz&Test.test_importUsedInMethodDefinitioncCr)z__future__ is special.zfrom __future__ import divisionze "docstring is allowed before future import" from __future__ import division NrNr;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)r8r9LateFutureImportr;rrrtest_futureImportFirsts zTest.test_futureImportFirstcCrZ)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 NrNr;rrrtest_futureImportUsedrzTest.test_futureImportUsedcCr6)z0Importing undefined names from __future__ fails.z8 from __future__ import print_statement Nr8r9FutureFeatureNotDefinedr;rrrtest_futureImportUndefinedzTest.test_futureImportUndefinedcCr6)z$Importing '*' from __future__ fails.z* from __future__ import * Nrr;rrrtest_futureImportStarrzTest.test_futureImportStarN)fr>r?r@rBrJrMrOrQrTrWrXr[r]r^r_rardrerfrgrhrlrmrnrorprqrtrurxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrrrrrrrAgs                             rAc@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__}. cCrj)zp An C{__all__} definition does not suppress unused import warnings in a function scope. zQ def foo(): import bar __all__ = ["bar"] N)r8r9r:rr;rrrtest_ignoredInFunctionsz%TestSpecialAll.test_ignoredInFunctioncCr6)z_ An C{__all__} definition in a class does not suppress unused import warnings. zM import bar class foo: __all__ = ["bar"] Nr7r;rrrtest_ignoredInClasssz"TestSpecialAll.test_ignoredInClasscCrc)Nz: import bar (__all__,) = ("foo",) r7r;rrr'test_ignored_when_not_directly_assignedsz6TestSpecialAll.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",) NrNr;rrrtest_warningSuppressed rz%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'] Nr8r9UndefinedExportr;rrrtest_augmentedAssignmentsz'TestSpecialAll.test_augmentedAssignmentcC|dtjtjtjtjdS)zP The C{__all__} variable is defined through list concatenation. zD import sys __all__ = ['a'] + ['b'] + ['c'] Nr8r9rr: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_assignment1rz2TestSpecialAll.test_tuple_concatenation_assignmentcCr`)NzF from foo import bar __all__ = [bar.__name__] rNr;rrrtest_all_with_attributes:rbz'TestSpecialAll.test_all_with_attributescCr`)Nz= from foo import bar __all__ = [bar] rNr;rrrtest_all_with_names@rz"TestSpecialAll.test_all_with_namescCr`)Nzs from foo import bar from bar import baz __all__ = [bar.__name__] + [baz.__name__] rNr;rrrtest_all_with_attributes_addedGrbz-TestSpecialAll.test_all_with_attributes_addedcCr`)Nzi from foo import bar from foo import baz __all__ = ['bar', baz.__name__] rNr;rrr%test_all_mixed_attributes_and_stringsNrbz4TestSpecialAll.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_unboundExportedUsz#TestSpecialAll.test_unboundExportedcCs|dtjtjtjtjdS)z6 Report undefined if import * is used zT from math import * __all__ = ['sin', 'cos'] csc(1) N)r8r9rImportStarUsager;rrrtest_importStarExporteddsz&TestSpecialAll.test_importStarExportedcCrj)z8Report unused import when not needed to satisfy __all__.zL from foolib import * a = 1 __all__ = ['a'] N)r8r9rr:r;rrrtest_importStarNotExportednsz)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)NrNr;rrrtest_usedInGenExpvs z TestSpecialAll.test_usedInGenExpcCrj)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))NrKr;rrrtest_redefinedByGenExp}sz%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" Nrrr;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 Nrrr;rrrtest_usedAsClassDecoratorrz(TestSpecialAll.test_usedAsClassDecoratorN)r>r?r@__doc__rrrrrrrrrrrrrrrrrrrrrrrs(       rN)pyflakesrr9pyflakes.checkerrrrrrpyflakes.test.harnessrr r rArrrrrs [