Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:45
📄 __init__.py	0 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 harness.py import ast import textwrap import unittest from pyflakes import checker __all__ = ['TestCase', 'skip', 'skipIf'] skip = unittest.skip skipIf = unittest.skipIf class TestCase(unittest.TestCase): withDoctest = False def flakes(self, input, expectedOutputs, kw): tree = ast.parse(textwrap.dedent(input)) file_tokens = checker.make_tokens(textwrap.dedent(input)) if kw.get('is_segment'): tree = tree.body[0] kw.pop('is_segment') w = checker.Checker( tree, file_tokens=file_tokens, withDoctest=self.withDoctest, *kw ) outputs = [type(o) for o in w.messages] expectedOutputs = list(expectedOutputs) outputs.sort(key=lambda t: t.__name__) expectedOutputs.sort(key=lambda t: t.__name__) self.assertEqual(outputs, expectedOutputs, '''\ for input: {} expected outputs: {!r} but got: {}'''.format(input, expectedOutputs, '\n'.join([str(o) for o in w.messages]))) return w	1004 B	2026-01-20 12:58
📄 test_api.py """ Tests for L{pyflakes.scripts.pyflakes}. """ import contextlib import io import os import sys import shutil import subprocess import tempfile from pyflakes.checker import PYPY from pyflakes.messages import UnusedImport from pyflakes.reporter import Reporter from pyflakes.api import ( main, check, checkPath, checkRecursive, iterSourceCode, ) from pyflakes.test.harness import TestCase, skipIf def withStderrTo(stderr, f, args, kwargs): """ Call C{f} with C{sys.stderr} redirected to C{stderr}. """ (outer, sys.stderr) = (sys.stderr, stderr) try: return f(args, *kwargs) finally: sys.stderr = outer class Node: """ Mock an AST node. """ def __init__(self, lineno, col_offset=0): self.lineno = lineno self.col_offset = col_offset class SysStreamCapturing: """Context manager capturing sys.stdin, sys.stdout and sys.stderr. The file handles are replaced with a StringIO object. """ def __init__(self, stdin): self._stdin = io.StringIO(stdin or '', newline=os.linesep) def __enter__(self): self._orig_stdin = sys.stdin self._orig_stdout = sys.stdout self._orig_stderr = sys.stderr sys.stdin = self._stdin sys.stdout = self._stdout_stringio = io.StringIO(newline=os.linesep) sys.stderr = self._stderr_stringio = io.StringIO(newline=os.linesep) return self def __exit__(self, args): self.output = self._stdout_stringio.getvalue() self.error = self._stderr_stringio.getvalue() sys.stdin = self._orig_stdin sys.stdout = self._orig_stdout sys.stderr = self._orig_stderr class LoggingReporter: """ Implementation of Reporter that just appends any error to a list. """ def __init__(self, log): """ Construct a C{LoggingReporter}. @param log: A list to append log messages to. """ self.log = log def flake(self, message): self.log.append(('flake', str(message))) def unexpectedError(self, filename, message): self.log.append(('unexpectedError', filename, message)) def syntaxError(self, filename, msg, lineno, offset, line): self.log.append(('syntaxError', filename, msg, lineno, offset, line)) class TestIterSourceCode(TestCase): """ Tests for L{iterSourceCode}. """ def setUp(self): self.tempdir = tempfile.mkdtemp() def tearDown(self): shutil.rmtree(self.tempdir) def makeEmptyFile(self, parts): assert parts fpath = os.path.join(self.tempdir, parts) open(fpath, 'a').close() return fpath def test_emptyDirectory(self): """ There are no Python files in an empty directory. """ self.assertEqual(list(iterSourceCode([self.tempdir])), []) def test_singleFile(self): """ If the directory contains one Python file, C{iterSourceCode} will find it. """ childpath = self.makeEmptyFile('foo.py') self.assertEqual(list(iterSourceCode([self.tempdir])), [childpath]) def test_onlyPythonSource(self): """ Files that are not Python source files are not included. """ self.makeEmptyFile('foo.pyc') self.assertEqual(list(iterSourceCode([self.tempdir])), []) def test_recurses(self): """ If the Python files are hidden deep down in child directories, we will find them. """ os.mkdir(os.path.join(self.tempdir, 'foo')) apath = self.makeEmptyFile('foo', 'a.py') self.makeEmptyFile('foo', 'a.py~') os.mkdir(os.path.join(self.tempdir, 'bar')) bpath = self.makeEmptyFile('bar', 'b.py') cpath = self.makeEmptyFile('c.py') self.assertEqual( sorted(iterSourceCode([self.tempdir])), sorted([apath, bpath, cpath])) def test_shebang(self): """ Find Python files that don't end with `.py`, but contain a Python shebang. """ python = os.path.join(self.tempdir, 'a') with open(python, 'w') as fd: fd.write('#!/usr/bin/env python\n') self.makeEmptyFile('b') with open(os.path.join(self.tempdir, 'c'), 'w') as fd: fd.write('hello\nworld\n') python3 = os.path.join(self.tempdir, 'e') with open(python3, 'w') as fd: fd.write('#!/usr/bin/env python3\n') pythonw = os.path.join(self.tempdir, 'f') with open(pythonw, 'w') as fd: fd.write('#!/usr/bin/env pythonw\n') python3args = os.path.join(self.tempdir, 'g') with open(python3args, 'w') as fd: fd.write('#!/usr/bin/python3 -u\n') python3d = os.path.join(self.tempdir, 'i') with open(python3d, 'w') as fd: fd.write('#!/usr/local/bin/python3d\n') python38m = os.path.join(self.tempdir, 'j') with open(python38m, 'w') as fd: fd.write('#! /usr/bin/env python3.8m\n') # Should NOT be treated as Python source notfirst = os.path.join(self.tempdir, 'l') with open(notfirst, 'w') as fd: fd.write('#!/bin/sh\n#!/usr/bin/python\n') self.assertEqual( sorted(iterSourceCode([self.tempdir])), sorted([ python, python3, pythonw, python3args, python3d, python38m, ])) def test_multipleDirectories(self): """ L{iterSourceCode} can be given multiple directories. It will recurse into each of them. """ foopath = os.path.join(self.tempdir, 'foo') barpath = os.path.join(self.tempdir, 'bar') os.mkdir(foopath) apath = self.makeEmptyFile('foo', 'a.py') os.mkdir(barpath) bpath = self.makeEmptyFile('bar', 'b.py') self.assertEqual( sorted(iterSourceCode([foopath, barpath])), sorted([apath, bpath])) def test_explicitFiles(self): """ If one of the paths given to L{iterSourceCode} is not a directory but a file, it will include that in its output. """ epath = self.makeEmptyFile('e.py') self.assertEqual(list(iterSourceCode([epath])), [epath]) class TestReporter(TestCase): """ Tests for L{Reporter}. """ def test_syntaxError(self): """ C{syntaxError} reports that there was a syntax error in the source file. It reports to the error stream and includes the filename, line number, error message, actual line of source and a caret pointing to where the error is. """ err = io.StringIO() reporter = Reporter(None, err) reporter.syntaxError('foo.py', 'a problem', 3, 8 if sys.version_info >= (3, 8) else 7, 'bad line of source') self.assertEqual( ("foo.py:3:8: a problem\n" "bad line of source\n" " ^\n"), err.getvalue()) def test_syntaxErrorNoOffset(self): """ C{syntaxError} doesn't include a caret pointing to the error if C{offset} is passed as C{None}. """ err = io.StringIO() reporter = Reporter(None, err) reporter.syntaxError('foo.py', 'a problem', 3, None, 'bad line of source') self.assertEqual( ("foo.py:3: a problem\n" "bad line of source\n"), err.getvalue()) def test_syntaxErrorNoText(self): """ C{syntaxError} doesn't include text or nonsensical offsets if C{text} is C{None}. This typically happens when reporting syntax errors from stdin. """ err = io.StringIO() reporter = Reporter(None, err) reporter.syntaxError('<stdin>', 'a problem', 0, 0, None) self.assertEqual(("<stdin>:1:1: a problem\n"), err.getvalue()) def test_multiLineSyntaxError(self): """ If there's a multi-line syntax error, then we only report the last line. The offset is adjusted so that it is relative to the start of the last line. """ err = io.StringIO() lines = [ 'bad line of source', 'more bad lines of source', ] reporter = Reporter(None, err) reporter.syntaxError('foo.py', 'a problem', 3, len(lines[0]) + 7, '\n'.join(lines)) column = 25 if sys.version_info >= (3, 8) else 7 self.assertEqual( ("foo.py:3:%d: a problem\n" % column + lines[-1] + "\n" + " " * (column - 1) + "^\n"), err.getvalue()) def test_unexpectedError(self): """ C{unexpectedError} reports an error processing a source file. """ err = io.StringIO() reporter = Reporter(None, err) reporter.unexpectedError('source.py', 'error message') self.assertEqual('source.py: error message\n', err.getvalue()) def test_flake(self): """ C{flake} reports a code warning from Pyflakes. It is exactly the str() of a L{pyflakes.messages.Message}. """ out = io.StringIO() reporter = Reporter(out, None) message = UnusedImport('foo.py', Node(42), 'bar') reporter.flake(message) self.assertEqual(out.getvalue(), f"{message}\n") class CheckTests(TestCase): """ Tests for L{check} and L{checkPath} which check a file for flakes. """ @contextlib.contextmanager def makeTempFile(self, content): """ Make a temporary file containing C{content} and return a path to it. """ fd, name = tempfile.mkstemp() try: with os.fdopen(fd, 'wb') as f: if not hasattr(content, 'decode'): content = content.encode('ascii') f.write(content) yield name finally: os.remove(name) def assertHasErrors(self, path, errorList): """ Assert that C{path} causes errors. @param path: A path to a file to check. @param errorList: A list of errors expected to be printed to stderr. """ err = io.StringIO() count = withStderrTo(err, checkPath, path) self.assertEqual( (count, err.getvalue()), (len(errorList), ''.join(errorList))) def getErrors(self, path): """ Get any warnings or errors reported by pyflakes for the file at C{path}. @param path: The path to a Python file on disk that pyflakes will check. @return: C{(count, log)}, where C{count} is the number of warnings or errors generated, and log is a list of those warnings, presented as structured data. See L{LoggingReporter} for more details. """ log = [] reporter = LoggingReporter(log) count = checkPath(path, reporter) return count, log def test_legacyScript(self): from pyflakes.scripts import pyflakes as script_pyflakes self.assertIs(script_pyflakes.checkPath, checkPath) def test_missingTrailingNewline(self): """ Source which doesn't end with a newline shouldn't cause any exception to be raised nor an error indicator to be returned by L{check}. """ with self.makeTempFile("def foo():\n\tpass\n\t") as fName: self.assertHasErrors(fName, []) def test_checkPathNonExisting(self): """ L{checkPath} handles non-existing files. """ count, errors = self.getErrors('extremo') self.assertEqual(count, 1) self.assertEqual( errors, [('unexpectedError', 'extremo', 'No such file or directory')]) def test_multilineSyntaxError(self): """ Source which includes a syntax error which results in the raised L{SyntaxError.text} containing multiple lines of source are reported with only the last line of that source. """ source = """\ def foo(): ''' def bar(): pass def baz(): '''quux''' """ # Sanity check - SyntaxError.text should be multiple lines, if it # isn't, something this test was unprepared for has happened. def evaluate(source): exec(source) try: evaluate(source) except SyntaxError as e: if not PYPY and sys.version_info < (3, 10): self.assertTrue(e.text.count('\n') > 1) else: self.fail() with self.makeTempFile(source) as sourcePath: if PYPY: message = 'end of file (EOF) while scanning triple-quoted string literal' elif sys.version_info >= (3, 10): message = 'unterminated triple-quoted string literal (detected at line 8)' # noqa: E501 else: message = 'invalid syntax' if PYPY or sys.version_info >= (3, 10): column = 12 elif sys.version_info >= (3, 8): column = 8 else: column = 11 self.assertHasErrors( sourcePath, ["""\ %s:8:%d: %s '''quux''' %s^ """ % (sourcePath, column, message, ' ' * (column - 1))]) def test_eofSyntaxError(self): """ The error reported for source files which end prematurely causing a syntax error reflects the cause for the syntax error. """ with self.makeTempFile("def foo(") as sourcePath: if PYPY: msg = 'parenthesis is never closed' elif sys.version_info >= (3, 10): msg = "'(' was never closed" else: msg = 'unexpected EOF while parsing' if PYPY or sys.version_info >= (3, 10): column = 8 else: column = 9 spaces = ' ' * (column - 1) expected = '{}:1:{}: {}\ndef foo(\n{}^\n'.format( sourcePath, column, msg, spaces ) self.assertHasErrors(sourcePath, [expected]) def test_eofSyntaxErrorWithTab(self): """ The error reported for source files which end prematurely causing a syntax error reflects the cause for the syntax error. """ with self.makeTempFile("if True:\n\tfoo =") as sourcePath: self.assertHasErrors( sourcePath, [f"""\ {sourcePath}:2:7: invalid syntax \tfoo = \t ^ """]) def test_nonDefaultFollowsDefaultSyntaxError(self): """ Source which has a non-default argument following a default argument should include the line number of the syntax error. However these exceptions do not include an offset. """ source = """\ def foo(bar=baz, bax): pass """ with self.makeTempFile(source) as sourcePath: if PYPY and sys.version_info >= (3, 9): column = 18 elif PYPY: column = 8 elif sys.version_info >= (3, 10): column = 18 elif sys.version_info >= (3, 9): column = 21 elif sys.version_info >= (3, 8): column = 9 else: column = 8 last_line = ' ' * (column - 1) + '^\n' columnstr = '%d:' % column self.assertHasErrors( sourcePath, ["""\ {}:1:{} non-default argument follows default argument def foo(bar=baz, bax): {}""".format(sourcePath, columnstr, last_line)]) def test_nonKeywordAfterKeywordSyntaxError(self): """ Source which has a non-keyword argument after a keyword argument should include the line number of the syntax error. However these exceptions do not include an offset. """ source = """\ foo(bar=baz, bax) """ with self.makeTempFile(source) as sourcePath: if sys.version_info >= (3, 9): column = 17 elif not PYPY and sys.version_info >= (3, 8): column = 14 else: column = 13 last_line = ' ' * (column - 1) + '^\n' columnstr = '%d:' % column message = 'positional argument follows keyword argument' self.assertHasErrors( sourcePath, ["""\ {}:1:{} {} foo(bar=baz, bax) {}""".format(sourcePath, columnstr, message, last_line)]) def test_invalidEscape(self): """ The invalid escape syntax raises ValueError in Python 2 """ # ValueError: invalid \x escape with self.makeTempFile(r"foo = '\xyz'") as sourcePath: position_end = 1 if PYPY and sys.version_info >= (3, 9): column = 7 elif PYPY: column = 6 elif sys.version_info >= (3, 9): column = 13 else: column = 7 last_line = '%s^\n' % (' ' * (column - 1)) decoding_error = """\ %s:1:%d: (unicode error) 'unicodeescape' codec can't decode bytes \ in position 0-%d: truncated \\xXX escape foo = '\\xyz' %s""" % (sourcePath, column, position_end, last_line) self.assertHasErrors( sourcePath, [decoding_error]) @skipIf(sys.platform == 'win32', 'unsupported on Windows') def test_permissionDenied(self): """ If the source file is not readable, this is reported on standard error. """ if os.getuid() == 0: self.skipTest('root user can access all files regardless of ' 'permissions') with self.makeTempFile('') as sourcePath: os.chmod(sourcePath, 0) count, errors = self.getErrors(sourcePath) self.assertEqual(count, 1) self.assertEqual( errors, [('unexpectedError', sourcePath, "Permission denied")]) def test_pyflakesWarning(self): """ If the source file has a pyflakes warning, this is reported as a 'flake'. """ with self.makeTempFile("import foo") as sourcePath: count, errors = self.getErrors(sourcePath) self.assertEqual(count, 1) self.assertEqual( errors, [('flake', str(UnusedImport(sourcePath, Node(1), 'foo')))]) def test_encodedFileUTF8(self): """ If source file declares the correct encoding, no error is reported. """ SNOWMAN = chr(0x2603) source = ("""\ # coding: utf-8 x = "%s" """ % SNOWMAN).encode('utf-8') with self.makeTempFile(source) as sourcePath: self.assertHasErrors(sourcePath, []) def test_CRLFLineEndings(self): """ Source files with Windows CR LF line endings are parsed successfully. """ with self.makeTempFile("x = 42\r\n") as sourcePath: self.assertHasErrors(sourcePath, []) def test_misencodedFileUTF8(self): """ If a source file contains bytes which cannot be decoded, this is reported on stderr. """ SNOWMAN = chr(0x2603) source = ("""\ # coding: ascii x = "%s" """ % SNOWMAN).encode('utf-8') with self.makeTempFile(source) as sourcePath: self.assertHasErrors( sourcePath, [f"{sourcePath}:1:1: 'ascii' codec can't decode byte 0xe2 in position 21: ordinal not in range(128)\n"]) # noqa: E501 def test_misencodedFileUTF16(self): """ If a source file contains bytes which cannot be decoded, this is reported on stderr. """ SNOWMAN = chr(0x2603) source = ("""\ # coding: ascii x = "%s" """ % SNOWMAN).encode('utf-16') with self.makeTempFile(source) as sourcePath: self.assertHasErrors( sourcePath, [f"{sourcePath}: problem decoding source\n"]) def test_checkRecursive(self): """ L{checkRecursive} descends into each directory, finding Python files and reporting problems. """ tempdir = tempfile.mkdtemp() try: os.mkdir(os.path.join(tempdir, 'foo')) file1 = os.path.join(tempdir, 'foo', 'bar.py') with open(file1, 'wb') as fd: fd.write(b"import baz\n") file2 = os.path.join(tempdir, 'baz.py') with open(file2, 'wb') as fd: fd.write(b"import contraband") log = [] reporter = LoggingReporter(log) warnings = checkRecursive([tempdir], reporter) self.assertEqual(warnings, 2) self.assertEqual( sorted(log), sorted([('flake', str(UnusedImport(file1, Node(1), 'baz'))), ('flake', str(UnusedImport(file2, Node(1), 'contraband')))])) finally: shutil.rmtree(tempdir) def test_stdinReportsErrors(self): """ L{check} reports syntax errors from stdin """ source = "max(1 for i in range(10), key=lambda x: x+1)\n" err = io.StringIO() count = withStderrTo(err, check, source, "<stdin>") self.assertEqual(count, 1) errlines = err.getvalue().split("\n")[:-1] if sys.version_info >= (3, 9): expected_error = [ "<stdin>:1:5: Generator expression must be parenthesized", "max(1 for i in range(10), key=lambda x: x+1)", " ^", ] elif PYPY: expected_error = [ "<stdin>:1:4: Generator expression must be parenthesized if not sole argument", # noqa: E501 "max(1 for i in range(10), key=lambda x: x+1)", " ^", ] elif sys.version_info >= (3, 8): expected_error = [ "<stdin>:1:5: Generator expression must be parenthesized", ] elif sys.version_info >= (3, 7): expected_error = [ "<stdin>:1:4: Generator expression must be parenthesized", ] elif sys.version_info >= (3, 6): expected_error = [ "<stdin>:1:4: Generator expression must be parenthesized if not sole argument", # noqa: E501 ] self.assertEqual(errlines, expected_error) class IntegrationTests(TestCase): """ Tests of the pyflakes script that actually spawn the script. """ def setUp(self): self.tempdir = tempfile.mkdtemp() self.tempfilepath = os.path.join(self.tempdir, 'temp') def tearDown(self): shutil.rmtree(self.tempdir) def getPyflakesBinary(self): """ Return the path to the pyflakes binary. """ import pyflakes package_dir = os.path.dirname(pyflakes.__file__) return os.path.join(package_dir, '..', 'bin', 'pyflakes') def runPyflakes(self, paths, stdin=None): """ Launch a subprocess running C{pyflakes}. @param paths: Command-line arguments to pass to pyflakes. @param stdin: Text to use as stdin. @return: C{(returncode, stdout, stderr)} of the completed pyflakes process. """ env = dict(os.environ) env['PYTHONPATH'] = os.pathsep.join(sys.path) command = [sys.executable, self.getPyflakesBinary()] command.extend(paths) if stdin: p = subprocess.Popen(command, env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = p.communicate(stdin.encode('ascii')) else: p = subprocess.Popen(command, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = p.communicate() rv = p.wait() stdout = stdout.decode('utf-8') stderr = stderr.decode('utf-8') return (stdout, stderr, rv) def test_goodFile(self): """ When a Python source file is all good, the return code is zero and no messages are printed to either stdout or stderr. """ open(self.tempfilepath, 'a').close() d = self.runPyflakes([self.tempfilepath]) self.assertEqual(d, ('', '', 0)) def test_fileWithFlakes(self): """ When a Python source file has warnings, the return code is non-zero and the warnings are printed to stdout. """ with open(self.tempfilepath, 'wb') as fd: fd.write(b"import contraband\n") d = self.runPyflakes([self.tempfilepath]) expected = UnusedImport(self.tempfilepath, Node(1), 'contraband') self.assertEqual(d, (f"{expected}{os.linesep}", '', 1)) def test_errors_io(self): """ When pyflakes finds errors with the files it's given, (if they don't exist, say), then the return code is non-zero and the errors are printed to stderr. """ d = self.runPyflakes([self.tempfilepath]) error_msg = '{}: No such file or directory{}'.format(self.tempfilepath, os.linesep) self.assertEqual(d, ('', error_msg, 1)) def test_errors_syntax(self): """ When pyflakes finds errors with the files it's given, (if they don't exist, say), then the return code is non-zero and the errors are printed to stderr. """ with open(self.tempfilepath, 'wb') as fd: fd.write(b"import") d = self.runPyflakes([self.tempfilepath]) error_msg = '{0}:1:7: invalid syntax{1}import{1} ^{1}'.format( self.tempfilepath, os.linesep) self.assertEqual(d, ('', error_msg, 1)) def test_readFromStdin(self): """ If no arguments are passed to C{pyflakes} then it reads from stdin. """ d = self.runPyflakes([], stdin='import contraband') expected = UnusedImport('<stdin>', Node(1), 'contraband') self.assertEqual(d, (f"{expected}{os.linesep}", '', 1)) class TestMain(IntegrationTests): """ Tests of the pyflakes main function. """ def runPyflakes(self, paths, stdin=None): try: with SysStreamCapturing(stdin) as capture: main(args=paths) except SystemExit as e: self.assertIsInstance(e.code, bool) rv = int(e.code) return (capture.output, capture.error, rv) else: raise RuntimeError('SystemExit not raised')	26.27 KB	2026-01-20 12:58
📄 test_builtin.py """ Tests for detecting redefinition of builtins. """ from pyflakes import messages as m from pyflakes.test.harness import TestCase class TestBuiltins(TestCase): def test_builtin_unbound_local(self): self.flakes(''' def foo(): a = range(1, 10) range = a return range foo() print(range) ''', m.UndefinedLocal) def test_global_shadowing_builtin(self): self.flakes(''' def f(): global range range = None print(range) f() ''')	582 B	2026-01-20 12:58
📄 test_checker.py import ast from pyflakes import checker from pyflakes.test.harness import TestCase class TypeableVisitorTests(TestCase): """ Tests of L{_TypeableVisitor} """ @staticmethod def _run_visitor(s): """ Run L{_TypeableVisitor} on the parsed source and return the visitor. """ tree = ast.parse(s) visitor = checker._TypeableVisitor() visitor.visit(tree) return visitor def test_node_types(self): """ Test that the typeable node types are collected """ visitor = self._run_visitor( """\ x = 1 # assignment for x in range(1): pass # for loop def f(): pass # function definition with a as b: pass # with statement """ ) self.assertEqual(visitor.typeable_lines, [1, 2, 3, 4]) self.assertIsInstance(visitor.typeable_nodes[1], ast.Assign) self.assertIsInstance(visitor.typeable_nodes[2], ast.For) self.assertIsInstance(visitor.typeable_nodes[3], ast.FunctionDef) self.assertIsInstance(visitor.typeable_nodes[4], ast.With) def test_visitor_recurses(self): """ Test the common pitfall of missing `generic_visit` in visitors by ensuring that nested nodes are reported """ visitor = self._run_visitor( """\ def f(): x = 1 """ ) self.assertEqual(visitor.typeable_lines, [1, 2]) self.assertIsInstance(visitor.typeable_nodes[1], ast.FunctionDef) self.assertIsInstance(visitor.typeable_nodes[2], ast.Assign) def test_py35_node_types(self): """ Test that the PEP 492 node types are collected """ visitor = self._run_visitor( """\ async def f(): # async def async for x in y: pass # async for async with a as b: pass # async with """ ) self.assertEqual(visitor.typeable_lines, [1, 2, 3]) self.assertIsInstance(visitor.typeable_nodes[1], ast.AsyncFunctionDef) self.assertIsInstance(visitor.typeable_nodes[2], ast.AsyncFor) self.assertIsInstance(visitor.typeable_nodes[3], ast.AsyncWith) def test_last_node_wins(self): """ Test that when two typeable nodes are present on a line, the last typeable one wins. """ visitor = self._run_visitor('x = 1; y = 1') # detected both assignable nodes self.assertEqual(visitor.typeable_lines, [1, 1]) # but the assignment to `y` wins self.assertEqual(visitor.typeable_nodes[1].targets[0].id, 'y') class CollectTypeCommentsTests(TestCase): """ Tests of L{_collect_type_comments} """ @staticmethod def _collect(s): """ Run L{_collect_type_comments} on the parsed source and return the mapping from nodes to comments. The return value is converted to a set: {(node_type, tuple of comments), ...} """ tree = ast.parse(s) tokens = checker.make_tokens(s) ret = checker._collect_type_comments(tree, tokens) return {(type(k), tuple(s for _, s in v)) for k, v in ret.items()} def test_bytes(self): """ Test that the function works for binary source """ ret = self._collect(b'x = 1 # type: int') self.assertSetEqual(ret, {(ast.Assign, ('# type: int',))}) def test_text(self): """ Test that the function works for text source """ ret = self._collect('x = 1 # type: int') self.assertEqual(ret, {(ast.Assign, ('# type: int',))}) def test_non_type_comment_ignored(self): """ Test that a non-type comment is ignored """ ret = self._collect('x = 1 # noqa') self.assertSetEqual(ret, set()) def test_type_comment_before_typeable(self): """ Test that a type comment before something typeable is ignored. """ ret = self._collect('# type: int\nx = 1') self.assertSetEqual(ret, set()) def test_type_ignore_comment_ignored(self): """ Test that `# type: ignore` comments are not collected. """ ret = self._collect('x = 1 # type: ignore') self.assertSetEqual(ret, set()) def test_type_ignore_with_other_things_ignored(self): """ Test that `# type: ignore` comments with more content are also not collected. """ ret = self._collect('x = 1 # type: ignore # noqa') self.assertSetEqual(ret, set()) ret = self._collect('x = 1 #type:ignore#noqa') self.assertSetEqual(ret, set()) def test_type_comment_with_extra_still_collected(self): ret = self._collect('x = 1 # type: int # noqa') self.assertSetEqual(ret, {(ast.Assign, ('# type: int # noqa',))}) def test_type_comment_without_whitespace(self): ret = self._collect('x = 1 #type:int') self.assertSetEqual(ret, {(ast.Assign, ('#type:int',))}) def test_type_comment_starts_with_word_ignore(self): ret = self._collect('x = 1 # type: ignore[T]') self.assertSetEqual(ret, set()) def test_last_node_wins(self): """ Test that when two typeable nodes are present on a line, the last typeable one wins. """ ret = self._collect('def f(): x = 1 # type: int') self.assertSetEqual(ret, {(ast.Assign, ('# type: int',))}) def test_function_def_assigned_comments(self): """ Test that type comments for function arguments are all attributed to the function definition. """ ret = self._collect( """\ def f( a, # type: int b, # type: str ): # type: (...) -> None pass """ ) expected = {( ast.FunctionDef, ('# type: int', '# type: str', '# type: (...) -> None'), )} self.assertSetEqual(ret, expected)	5.78 KB	2026-01-20 12:58
📄 test_code_segment.py from pyflakes import messages as m from pyflakes.checker import (FunctionScope, ClassScope, ModuleScope, Argument, FunctionDefinition, Assignment) from pyflakes.test.harness import TestCase class TestCodeSegments(TestCase): """ Tests for segments of a module """ def test_function_segment(self): self.flakes(''' def foo(): def bar(): pass ''', is_segment=True) self.flakes(''' def foo(): def bar(): x = 0 ''', m.UnusedVariable, is_segment=True) def test_class_segment(self): self.flakes(''' class Foo: class Bar: pass ''', is_segment=True) self.flakes(''' class Foo: def bar(): x = 0 ''', m.UnusedVariable, is_segment=True) def test_scope_class(self): checker = self.flakes(''' class Foo: x = 0 def bar(a, b=1, d, e): pass ''', is_segment=True) scopes = checker.deadScopes module_scopes = [ scope for scope in scopes if scope.__class__ is ModuleScope] class_scopes = [ scope for scope in scopes if scope.__class__ is ClassScope] function_scopes = [ scope for scope in scopes if scope.__class__ is FunctionScope] # Ensure module scope is not present because we are analysing # the inner contents of Foo self.assertEqual(len(module_scopes), 0) self.assertEqual(len(class_scopes), 1) self.assertEqual(len(function_scopes), 1) class_scope = class_scopes[0] function_scope = function_scopes[0] self.assertIsInstance(class_scope, ClassScope) self.assertIsInstance(function_scope, FunctionScope) self.assertIn('x', class_scope) self.assertIn('bar', class_scope) self.assertIn('a', function_scope) self.assertIn('b', function_scope) self.assertIn('d', function_scope) self.assertIn('e', function_scope) self.assertIsInstance(class_scope['bar'], FunctionDefinition) self.assertIsInstance(class_scope['x'], Assignment) self.assertIsInstance(function_scope['a'], Argument) self.assertIsInstance(function_scope['b'], Argument) self.assertIsInstance(function_scope['d'], Argument) self.assertIsInstance(function_scope['e'], Argument) def test_scope_function(self): checker = self.flakes(''' def foo(a, b=1, d, *e): def bar(f, g=1, h, **i): pass ''', is_segment=True) scopes = checker.deadScopes module_scopes = [ scope for scope in scopes if scope.__class__ is ModuleScope] function_scopes = [ scope for scope in scopes if scope.__class__ is FunctionScope] # Ensure module scope is not present because we are analysing # the inner contents of foo self.assertEqual(len(module_scopes), 0) self.assertEqual(len(function_scopes), 2) function_scope_foo = function_scopes[1] function_scope_bar = function_scopes[0] self.assertIsInstance(function_scope_foo, FunctionScope) self.assertIsInstance(function_scope_bar, FunctionScope) self.assertIn('a', function_scope_foo) self.assertIn('b', function_scope_foo) self.assertIn('d', function_scope_foo) self.assertIn('e', function_scope_foo) self.assertIn('bar', function_scope_foo) self.assertIn('f', function_scope_bar) self.assertIn('g', function_scope_bar) self.assertIn('h', function_scope_bar) self.assertIn('i', function_scope_bar) self.assertIsInstance(function_scope_foo['bar'], FunctionDefinition) self.assertIsInstance(function_scope_foo['a'], Argument) self.assertIsInstance(function_scope_foo['b'], Argument) self.assertIsInstance(function_scope_foo['d'], Argument) self.assertIsInstance(function_scope_foo['e'], Argument) self.assertIsInstance(function_scope_bar['f'], Argument) self.assertIsInstance(function_scope_bar['g'], Argument) self.assertIsInstance(function_scope_bar['h'], Argument) self.assertIsInstance(function_scope_bar['i'], Argument) def test_scope_async_function(self): self.flakes('async def foo(): pass', is_segment=True)	4.39 KB	2026-01-20 12:58
📄 test_dict.py """ Tests for dict duplicate keys Pyflakes behavior. """ from pyflakes import messages as m from pyflakes.test.harness import TestCase class Test(TestCase): def test_duplicate_keys(self): self.flakes( "{'yes': 1, 'yes': 2}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_bytes_vs_unicode_py3(self): self.flakes("{b'a': 1, u'a': 2}") def test_duplicate_values_bytes_vs_unicode_py3(self): self.flakes( "{1: b'a', 1: u'a'}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_multiple_duplicate_keys(self): self.flakes( "{'yes': 1, 'yes': 2, 'no': 2, 'no': 3}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_in_function(self): self.flakes( ''' def f(thing): pass f({'yes': 1, 'yes': 2}) ''', m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_in_lambda(self): self.flakes( "lambda x: {(0,1): 1, (0,1): 2}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_tuples(self): self.flakes( "{(0,1): 1, (0,1): 2}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_tuples_int_and_float(self): self.flakes( "{(0,1): 1, (0,1.0): 2}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_ints(self): self.flakes( "{1: 1, 1: 2}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_bools(self): self.flakes( "{True: 1, True: 2}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_bools_false(self): # Needed to ensure 2.x correctly coerces these from variables self.flakes( "{False: 1, False: 2}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_keys_none(self): self.flakes( "{None: 1, None: 2}", m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_variable_keys(self): self.flakes( ''' a = 1 {a: 1, a: 2} ''', m.MultiValueRepeatedKeyVariable, m.MultiValueRepeatedKeyVariable, ) def test_duplicate_variable_values(self): self.flakes( ''' a = 1 b = 2 {1: a, 1: b} ''', m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_variable_values_same_value(self): # Current behaviour is not to look up variable values. This is to # confirm that. self.flakes( ''' a = 1 b = 1 {1: a, 1: b} ''', m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_duplicate_key_float_and_int(self): """ These do look like different values, but when it comes to their use as keys, they compare as equal and so are actually duplicates. The literal dict {1: 1, 1.0: 1} actually becomes {1.0: 1}. """ self.flakes( ''' {1: 1, 1.0: 2} ''', m.MultiValueRepeatedKeyLiteral, m.MultiValueRepeatedKeyLiteral, ) def test_no_duplicate_key_error_same_value(self): self.flakes(''' {'yes': 1, 'yes': 1} ''') def test_no_duplicate_key_errors(self): self.flakes(''' {'yes': 1, 'no': 2} ''') def test_no_duplicate_keys_tuples_same_first_element(self): self.flakes("{(0,1): 1, (0,2): 1}") def test_no_duplicate_key_errors_func_call(self): self.flakes(''' def test(thing): pass test({True: 1, None: 2, False: 1}) ''') def test_no_duplicate_key_errors_bool_or_none(self): self.flakes("{True: 1, None: 2, False: 1}") def test_no_duplicate_key_errors_ints(self): self.flakes(''' {1: 1, 2: 1} ''') def test_no_duplicate_key_errors_vars(self): self.flakes(''' test = 'yes' rest = 'yes' {test: 1, rest: 2} ''') def test_no_duplicate_key_errors_tuples(self): self.flakes(''' {(0,1): 1, (0,2): 1} ''') def test_no_duplicate_key_errors_instance_attributes(self): self.flakes(''' class Test(): pass f = Test() f.a = 1 {f.a: 1, f.a: 1} ''')	5.15 KB	2026-01-20 12:58
📄 test_doctests.py import sys import textwrap from pyflakes import messages as m from pyflakes.checker import ( PYPY, DoctestScope, FunctionScope, ModuleScope, ) from pyflakes.test.test_other import Test as TestOther from pyflakes.test.test_imports import Test as TestImports from pyflakes.test.test_undefined_names import Test as TestUndefinedNames from pyflakes.test.harness import TestCase, skip class _DoctestMixin: withDoctest = True def doctestify(self, input): lines = [] for line in textwrap.dedent(input).splitlines(): if line.strip() == '': pass elif (line.startswith(' ') or line.startswith('except:') or line.startswith('except ') or line.startswith('finally:') or line.startswith('else:') or line.startswith('elif ') or (lines and lines[-1].startswith(('>>> @', '... @')))): line = "... %s" % line else: line = ">>> %s" % line lines.append(line) doctestificator = textwrap.dedent('''\ def doctest_something(): """ %s """ ''') return doctestificator % "\n ".join(lines) def flakes(self, input, args, kw): return super().flakes(self.doctestify(input), args, *kw) class Test(TestCase): withDoctest = True def test_scope_class(self): """Check that a doctest is given a DoctestScope.""" checker = self.flakes(""" m = None def doctest_stuff(): ''' >>> d = doctest_stuff() ''' f = m return f """) scopes = checker.deadScopes module_scopes = [ scope for scope in scopes if scope.__class__ is ModuleScope] doctest_scopes = [ scope for scope in scopes if scope.__class__ is DoctestScope] function_scopes = [ scope for scope in scopes if scope.__class__ is FunctionScope] self.assertEqual(len(module_scopes), 1) self.assertEqual(len(doctest_scopes), 1) module_scope = module_scopes[0] doctest_scope = doctest_scopes[0] self.assertIsInstance(doctest_scope, DoctestScope) self.assertIsInstance(doctest_scope, ModuleScope) self.assertNotIsInstance(doctest_scope, FunctionScope) self.assertNotIsInstance(module_scope, DoctestScope) self.assertIn('m', module_scope) self.assertIn('doctest_stuff', module_scope) self.assertIn('d', doctest_scope) self.assertEqual(len(function_scopes), 1) self.assertIn('f', function_scopes[0]) def test_nested_doctest_ignored(self): """Check that nested doctests are ignored.""" checker = self.flakes(""" m = None def doctest_stuff(): ''' >>> def function_in_doctest(): ... \"\"\" ... >>> ignored_undefined_name ... \"\"\" ... df = m ... return df ... >>> function_in_doctest() ''' f = m return f """) scopes = checker.deadScopes module_scopes = [ scope for scope in scopes if scope.__class__ is ModuleScope] doctest_scopes = [ scope for scope in scopes if scope.__class__ is DoctestScope] function_scopes = [ scope for scope in scopes if scope.__class__ is FunctionScope] self.assertEqual(len(module_scopes), 1) self.assertEqual(len(doctest_scopes), 1) module_scope = module_scopes[0] doctest_scope = doctest_scopes[0] self.assertIn('m', module_scope) self.assertIn('doctest_stuff', module_scope) self.assertIn('function_in_doctest', doctest_scope) self.assertEqual(len(function_scopes), 2) self.assertIn('f', function_scopes[0]) self.assertIn('df', function_scopes[1]) def test_global_module_scope_pollution(self): """Check that global in doctest does not pollute module scope.""" checker = self.flakes(""" def doctest_stuff(): ''' >>> def function_in_doctest(): ... global m ... m = 50 ... df = 10 ... m = df ... >>> function_in_doctest() ''' f = 10 return f """) scopes = checker.deadScopes module_scopes = [ scope for scope in scopes if scope.__class__ is ModuleScope] doctest_scopes = [ scope for scope in scopes if scope.__class__ is DoctestScope] function_scopes = [ scope for scope in scopes if scope.__class__ is FunctionScope] self.assertEqual(len(module_scopes), 1) self.assertEqual(len(doctest_scopes), 1) module_scope = module_scopes[0] doctest_scope = doctest_scopes[0] self.assertIn('doctest_stuff', module_scope) self.assertIn('function_in_doctest', doctest_scope) self.assertEqual(len(function_scopes), 2) self.assertIn('f', function_scopes[0]) self.assertIn('df', function_scopes[1]) self.assertIn('m', function_scopes[1]) self.assertNotIn('m', module_scope) def test_global_undefined(self): self.flakes(""" global m def doctest_stuff(): ''' >>> m ''' """, m.UndefinedName) def test_nested_class(self): """Doctest within nested class are processed.""" self.flakes(""" class C: class D: ''' >>> m ''' def doctest_stuff(self): ''' >>> m ''' return 1 """, m.UndefinedName, m.UndefinedName) def test_ignore_nested_function(self): """Doctest module does not process doctest in nested functions.""" # 'syntax error' would cause a SyntaxError if the doctest was processed. # However doctest does not find doctest in nested functions # (https://bugs.python.org/issue1650090). If nested functions were # processed, this use of m should cause UndefinedName, and the # name inner_function should probably exist in the doctest scope. self.flakes(""" def doctest_stuff(): def inner_function(): ''' >>> syntax error >>> inner_function() 1 >>> m ''' return 1 m = inner_function() return m """) def test_inaccessible_scope_class(self): """Doctest may not access class scope.""" self.flakes(""" class C: def doctest_stuff(self): ''' >>> m ''' return 1 m = 1 """, m.UndefinedName) def test_importBeforeDoctest(self): self.flakes(""" import foo def doctest_stuff(): ''' >>> foo ''' """) @skip("todo") def test_importBeforeAndInDoctest(self): self.flakes(''' import foo def doctest_stuff(): """ >>> import foo >>> foo """ foo ''', m.RedefinedWhileUnused) def test_importInDoctestAndAfter(self): self.flakes(''' def doctest_stuff(): """ >>> import foo >>> foo """ import foo foo() ''') def test_offsetInDoctests(self): exc = self.flakes(''' def doctest_stuff(): """ >>> x # line 5 """ ''', m.UndefinedName).messages[0] self.assertEqual(exc.lineno, 5) self.assertEqual(exc.col, 12) def test_offsetInLambdasInDoctests(self): exc = self.flakes(''' def doctest_stuff(): """ >>> lambda: x # line 5 """ ''', m.UndefinedName).messages[0] self.assertEqual(exc.lineno, 5) self.assertEqual(exc.col, 20) def test_offsetAfterDoctests(self): exc = self.flakes(''' def doctest_stuff(): """ >>> x = 5 """ x ''', m.UndefinedName).messages[0] self.assertEqual(exc.lineno, 8) self.assertEqual(exc.col, 0) def test_syntaxErrorInDoctest(self): exceptions = self.flakes( ''' def doctest_stuff(): """ >>> from # line 4 >>> fortytwo = 42 >>> except Exception: """ ''', m.DoctestSyntaxError, m.DoctestSyntaxError, m.DoctestSyntaxError).messages exc = exceptions[0] self.assertEqual(exc.lineno, 4) if not PYPY and sys.version_info >= (3, 8): self.assertEqual(exc.col, 18) else: self.assertEqual(exc.col, 26) # PyPy error column offset is 0, # for the second and third line of the doctest # i.e. at the beginning of the line exc = exceptions[1] self.assertEqual(exc.lineno, 5) if PYPY: self.assertEqual(exc.col, 13) else: self.assertEqual(exc.col, 16) exc = exceptions[2] self.assertEqual(exc.lineno, 6) if PYPY or sys.version_info >= (3, 8): self.assertEqual(exc.col, 13) else: self.assertEqual(exc.col, 18) def test_indentationErrorInDoctest(self): exc = self.flakes(''' def doctest_stuff(): """ >>> if True: ... pass """ ''', m.DoctestSyntaxError).messages[0] self.assertEqual(exc.lineno, 5) if PYPY or sys.version_info >= (3, 8): self.assertEqual(exc.col, 13) else: self.assertEqual(exc.col, 16) def test_offsetWithMultiLineArgs(self): (exc1, exc2) = self.flakes( ''' def doctest_stuff(arg1, arg2, arg3): """ >>> assert >>> this """ ''', m.DoctestSyntaxError, m.UndefinedName).messages self.assertEqual(exc1.lineno, 6) self.assertEqual(exc1.col, 19) self.assertEqual(exc2.lineno, 7) self.assertEqual(exc2.col, 12) def test_doctestCanReferToFunction(self): self.flakes(""" def foo(): ''' >>> foo ''' """) def test_doctestCanReferToClass(self): self.flakes(""" class Foo(): ''' >>> Foo ''' def bar(self): ''' >>> Foo ''' """) def test_noOffsetSyntaxErrorInDoctest(self): exceptions = self.flakes( ''' def buildurl(base, args, **kwargs): """ >>> buildurl('/blah.php', ('a', '&'), ('b', '=') '/blah.php?a=%26&b=%3D' >>> buildurl('/blah.php', a='&', 'b'='=') '/blah.php?b=%3D&a=%26' """ pass ''', m.DoctestSyntaxError, m.DoctestSyntaxError).messages exc = exceptions[0] self.assertEqual(exc.lineno, 4) exc = exceptions[1] self.assertEqual(exc.lineno, 6) def test_singleUnderscoreInDoctest(self): self.flakes(''' def func(): """A docstring >>> func() 1 >>> _ 1 """ return 1 ''') def test_globalUnderscoreInDoctest(self): self.flakes(""" from gettext import ugettext as _ def doctest_stuff(): ''' >>> pass ''' """, m.UnusedImport) class TestOther(_DoctestMixin, TestOther): """Run TestOther with each test wrapped in a doctest.""" class TestImports(_DoctestMixin, TestImports): """Run TestImports with each test wrapped in a doctest.""" class TestUndefinedNames(_DoctestMixin, TestUndefinedNames): """Run TestUndefinedNames with each test wrapped in a doctest."""	12.55 KB	2026-01-20 12:58
📄 test_imports.py from pyflakes import messages as m from pyflakes.checker import ( FutureImportation, Importation, ImportationFrom, StarImportation, SubmoduleImportation, ) from pyflakes.test.harness import TestCase, skip class TestImportationObject(TestCase): def test_import_basic(self): binding = Importation('a', None, 'a') assert binding.source_statement == 'import a' assert str(binding) == 'a' def test_import_as(self): binding = Importation('c', None, 'a') assert binding.source_statement == 'import a as c' assert str(binding) == 'a as c' def test_import_submodule(self): binding = SubmoduleImportation('a.b', None) assert binding.source_statement == 'import a.b' assert str(binding) == 'a.b' def test_import_submodule_as(self): # A submodule import with an as clause is not a SubmoduleImportation binding = Importation('c', None, 'a.b') assert binding.source_statement == 'import a.b as c' assert str(binding) == 'a.b as c' def test_import_submodule_as_source_name(self): binding = Importation('a', None, 'a.b') assert binding.source_statement == 'import a.b as a' assert str(binding) == 'a.b as a' def test_importfrom_relative(self): binding = ImportationFrom('a', None, '.', 'a') assert binding.source_statement == 'from . import a' assert str(binding) == '.a' def test_importfrom_relative_parent(self): binding = ImportationFrom('a', None, '..', 'a') assert binding.source_statement == 'from .. import a' assert str(binding) == '..a' def test_importfrom_relative_with_module(self): binding = ImportationFrom('b', None, '..a', 'b') assert binding.source_statement == 'from ..a import b' assert str(binding) == '..a.b' def test_importfrom_relative_with_module_as(self): binding = ImportationFrom('c', None, '..a', 'b') assert binding.source_statement == 'from ..a import b as c' assert str(binding) == '..a.b as c' def test_importfrom_member(self): binding = ImportationFrom('b', None, 'a', 'b') assert binding.source_statement == 'from a import b' assert str(binding) == 'a.b' def test_importfrom_submodule_member(self): binding = ImportationFrom('c', None, 'a.b', 'c') assert binding.source_statement == 'from a.b import c' assert str(binding) == 'a.b.c' def test_importfrom_member_as(self): binding = ImportationFrom('c', None, 'a', 'b') assert binding.source_statement == 'from a import b as c' assert str(binding) == 'a.b as c' def test_importfrom_submodule_member_as(self): binding = ImportationFrom('d', None, 'a.b', 'c') assert binding.source_statement == 'from a.b import c as d' assert str(binding) == 'a.b.c as d' def test_importfrom_star(self): binding = StarImportation('a.b', None) assert binding.source_statement == 'from a.b import ' assert str(binding) == 'a.b.' def test_importfrom_star_relative(self): binding = StarImportation('.b', None) assert binding.source_statement == 'from .b import ' assert str(binding) == '.b.' def test_importfrom_future(self): binding = FutureImportation('print_function', None, None) assert binding.source_statement == 'from __future__ import print_function' assert str(binding) == '__future__.print_function' def test_unusedImport_underscore(self): """ The magic underscore var should be reported as unused when used as an import alias. """ self.flakes('import fu as _', m.UnusedImport) class Test(TestCase): def test_unusedImport(self): self.flakes('import fu, bar', m.UnusedImport, m.UnusedImport) self.flakes('from baz import fu, bar', m.UnusedImport, m.UnusedImport) def test_unusedImport_relative(self): self.flakes('from . import fu', m.UnusedImport) self.flakes('from . import fu as baz', m.UnusedImport) self.flakes('from .. import fu', m.UnusedImport) self.flakes('from ... import fu', m.UnusedImport) self.flakes('from .. import fu as baz', m.UnusedImport) self.flakes('from .bar import fu', m.UnusedImport) self.flakes('from ..bar import fu', m.UnusedImport) self.flakes('from ...bar import fu', m.UnusedImport) self.flakes('from ...bar import fu as baz', m.UnusedImport) checker = self.flakes('from . import fu', m.UnusedImport) error = checker.messages[0] assert error.message == '%r imported but unused' assert error.message_args == ('.fu', ) checker = self.flakes('from . import fu as baz', m.UnusedImport) error = checker.messages[0] assert error.message == '%r imported but unused' assert error.message_args == ('.fu as baz', ) def test_aliasedImport(self): self.flakes('import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport) self.flakes('from moo import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport) def test_aliasedImportShadowModule(self): """Imported aliases can shadow the source of the import.""" self.flakes('from moo import fu as moo; moo') self.flakes('import fu as fu; fu') self.flakes('import fu.bar as fu; fu') def test_usedImport(self): self.flakes('import fu; print(fu)') self.flakes('from baz import fu; print(fu)') self.flakes('import fu; del fu') def test_usedImport_relative(self): self.flakes('from . import fu; assert fu') self.flakes('from .bar import fu; assert fu') self.flakes('from .. import fu; assert fu') self.flakes('from ..bar import fu as baz; assert baz') def test_redefinedWhileUnused(self): self.flakes('import fu; fu = 3', m.RedefinedWhileUnused) self.flakes('import fu; fu, bar = 3', m.RedefinedWhileUnused) self.flakes('import fu; [fu, bar] = 3', m.RedefinedWhileUnused) def test_redefinedIf(self): """ Test that importing a module twice within an if block does raise a warning. """ self.flakes(''' i = 2 if i==1: import os import os os.path''', m.RedefinedWhileUnused) def test_redefinedIfElse(self): """ Test that importing a module twice in if and else blocks does not raise a warning. """ self.flakes(''' i = 2 if i==1: import os else: import os os.path''') def test_redefinedTry(self): """ Test that importing a module twice in a try block does raise a warning. """ self.flakes(''' try: import os import os except: pass os.path''', m.RedefinedWhileUnused) def test_redefinedTryExcept(self): """ Test that importing a module twice in a try and except block does not raise a warning. """ self.flakes(''' try: import os except: import os os.path''') def test_redefinedTryNested(self): """ Test that importing a module twice using a nested try/except and if blocks does not issue a warning. """ self.flakes(''' try: if True: if True: import os except: import os os.path''') def test_redefinedTryExceptMulti(self): self.flakes(""" try: from aa import mixer except AttributeError: from bb import mixer except RuntimeError: from cc import mixer except: from dd import mixer mixer(123) """) def test_redefinedTryElse(self): self.flakes(""" try: from aa import mixer except ImportError: pass else: from bb import mixer mixer(123) """, m.RedefinedWhileUnused) def test_redefinedTryExceptElse(self): self.flakes(""" try: import funca except ImportError: from bb import funca from bb import funcb else: from bbb import funcb print(funca, funcb) """) def test_redefinedTryExceptFinally(self): self.flakes(""" try: from aa import a except ImportError: from bb import a finally: a = 42 print(a) """) def test_redefinedTryExceptElseFinally(self): self.flakes(""" try: import b except ImportError: b = Ellipsis from bb import a else: from aa import a finally: a = 42 print(a, b) """) def test_redefinedByFunction(self): self.flakes(''' import fu def fu(): pass ''', m.RedefinedWhileUnused) def test_redefinedInNestedFunction(self): """ Test that shadowing a global name with a nested function definition generates a warning. """ self.flakes(''' import fu def bar(): def baz(): def fu(): pass ''', m.RedefinedWhileUnused, m.UnusedImport) def test_redefinedInNestedFunctionTwice(self): """ Test that shadowing a global name with a nested function definition generates a warning. """ self.flakes(''' import fu def bar(): import fu def baz(): def fu(): pass ''', m.RedefinedWhileUnused, m.RedefinedWhileUnused, m.UnusedImport, m.UnusedImport) def test_redefinedButUsedLater(self): """ Test that a global import which is redefined locally, but used later in another scope does not generate a warning. """ self.flakes(''' 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() ''') def test_redefinedByClass(self): self.flakes(''' import fu class fu: pass ''', m.RedefinedWhileUnused) def test_redefinedBySubclass(self): """ If an imported name is redefined by a class statement which also uses that name in the bases list, no warning is emitted. """ self.flakes(''' from fu import bar class bar(bar): pass ''') def test_redefinedInClass(self): """ Test that shadowing a global with a class attribute does not produce a warning. """ self.flakes(''' import fu class bar: fu = 1 print(fu) ''') def test_importInClass(self): """ Test that import within class is a locally scoped attribute. """ self.flakes(''' class bar: import fu ''') self.flakes(''' class bar: import fu fu ''', m.UndefinedName) def test_usedInFunction(self): self.flakes(''' import fu def fun(): print(fu) ''') def test_shadowedByParameter(self): self.flakes(''' import fu def fun(fu): print(fu) ''', m.UnusedImport, m.RedefinedWhileUnused) self.flakes(''' import fu def fun(fu): print(fu) print(fu) ''') def test_newAssignment(self): self.flakes('fu = None') def test_usedInGetattr(self): self.flakes('import fu; fu.bar.baz') self.flakes('import fu; "bar".fu.baz', m.UnusedImport) def test_usedInSlice(self): self.flakes('import fu; print(fu.bar[1:])') def test_usedInIfBody(self): self.flakes(''' import fu if True: print(fu) ''') def test_usedInIfConditional(self): self.flakes(''' import fu if fu: pass ''') def test_usedInElifConditional(self): self.flakes(''' import fu if False: pass elif fu: pass ''') def test_usedInElse(self): self.flakes(''' import fu if False: pass else: print(fu) ''') def test_usedInCall(self): self.flakes('import fu; fu.bar()') def test_usedInClass(self): self.flakes(''' import fu class bar: bar = fu ''') def test_usedInClassBase(self): self.flakes(''' import fu class bar(object, fu.baz): pass ''') def test_notUsedInNestedScope(self): self.flakes(''' import fu def bleh(): pass print(fu) ''') def test_usedInFor(self): self.flakes(''' import fu for bar in range(9): print(fu) ''') def test_usedInForElse(self): self.flakes(''' import fu for bar in range(10): pass else: print(fu) ''') def test_redefinedByFor(self): self.flakes(''' import fu for fu in range(2): pass ''', m.ImportShadowedByLoopVar) def test_shadowedByFor(self): """ Test that shadowing a global name with a for loop variable generates a warning. """ self.flakes(''' import fu fu.bar() for fu in (): pass ''', m.ImportShadowedByLoopVar) def test_shadowedByForDeep(self): """ Test that shadowing a global name with a for loop variable nested in a tuple unpack generates a warning. """ self.flakes(''' import fu fu.bar() for (x, y, z, (a, b, c, (fu,))) in (): pass ''', m.ImportShadowedByLoopVar) # Same with a list instead of a tuple self.flakes(''' import fu fu.bar() for [x, y, z, (a, b, c, (fu,))] in (): pass ''', m.ImportShadowedByLoopVar) def test_usedInReturn(self): self.flakes(''' import fu def fun(): return fu ''') def test_usedInOperators(self): self.flakes('import fu; 3 + fu.bar') self.flakes('import fu; 3 % fu.bar') self.flakes('import fu; 3 - fu.bar') self.flakes('import fu; 3 * fu.bar') self.flakes('import fu; 3 ** fu.bar') self.flakes('import fu; 3 / fu.bar') self.flakes('import fu; 3 // fu.bar') self.flakes('import fu; -fu.bar') self.flakes('import fu; ~fu.bar') self.flakes('import fu; 1 == fu.bar') self.flakes('import fu; 1 \| fu.bar') self.flakes('import fu; 1 & fu.bar') self.flakes('import fu; 1 ^ fu.bar') self.flakes('import fu; 1 >> fu.bar') self.flakes('import fu; 1 << fu.bar') def test_usedInAssert(self): self.flakes('import fu; assert fu.bar') def test_usedInSubscript(self): self.flakes('import fu; fu.bar[1]') def test_usedInLogic(self): self.flakes('import fu; fu and False') self.flakes('import fu; fu or False') self.flakes('import fu; not fu.bar') def test_usedInList(self): self.flakes('import fu; [fu]') def test_usedInTuple(self): self.flakes('import fu; (fu,)') def test_usedInTry(self): self.flakes(''' import fu try: fu except: pass ''') def test_usedInExcept(self): self.flakes(''' import fu try: fu except: pass ''') def test_redefinedByExcept(self): expected = [m.RedefinedWhileUnused] # The exc variable is unused inside the exception handler. expected.append(m.UnusedVariable) self.flakes(''' import fu try: pass except Exception as fu: pass ''', expected) def test_usedInRaise(self): self.flakes(''' import fu raise fu.bar ''') def test_usedInYield(self): self.flakes(''' import fu def gen(): yield fu ''') def test_usedInDict(self): self.flakes('import fu; {fu:None}') self.flakes('import fu; {1:fu}') def test_usedInParameterDefault(self): self.flakes(''' import fu def f(bar=fu): pass ''') def test_usedInAttributeAssign(self): self.flakes('import fu; fu.bar = 1') def test_usedInKeywordArg(self): self.flakes('import fu; fu.bar(stuff=fu)') def test_usedInAssignment(self): self.flakes('import fu; bar=fu') self.flakes('import fu; n=0; n+=fu') def test_usedInListComp(self): self.flakes('import fu; [fu for _ in range(1)]') self.flakes('import fu; [1 for _ in range(1) if fu]') def test_usedInTryFinally(self): self.flakes(''' import fu try: pass finally: fu ''') self.flakes(''' import fu try: fu finally: pass ''') def test_usedInWhile(self): self.flakes(''' import fu while 0: fu ''') self.flakes(''' import fu while fu: pass ''') def test_usedInGlobal(self): """ A 'global' statement shadowing an unused import should not prevent it from being reported. """ self.flakes(''' import fu def f(): global fu ''', m.UnusedImport) def test_usedAndGlobal(self): """ A 'global' statement shadowing a used import should not cause it to be reported as unused. """ self.flakes(''' import foo def f(): global foo def g(): foo.is_used() ''') def test_assignedToGlobal(self): """ Binding an import to a declared global should not cause it to be reported as unused. """ self.flakes(''' def f(): global foo; import foo def g(): foo.is_used() ''') def test_usedInExec(self): exec_stmt = 'exec("print(1)", fu.bar)' self.flakes('import fu; %s' % exec_stmt) def test_usedInLambda(self): self.flakes('import fu; lambda: fu') def test_shadowedByLambda(self): self.flakes('import fu; lambda fu: fu', m.UnusedImport, m.RedefinedWhileUnused) self.flakes('import fu; lambda fu: fu\nfu()') def test_usedInSliceObj(self): self.flakes('import fu; "meow"[::fu]') def test_unusedInNestedScope(self): self.flakes(''' def bar(): import fu fu ''', m.UnusedImport, m.UndefinedName) def test_methodsDontUseClassScope(self): self.flakes(''' class bar: import fu def fun(self): fu ''', m.UndefinedName) def test_nestedFunctionsNestScope(self): self.flakes(''' def a(): def b(): fu import fu ''') def test_nestedClassAndFunctionScope(self): self.flakes(''' def a(): import fu class b: def c(self): print(fu) ''') def test_importStar(self): """Use of import at module level is reported.""" self.flakes('from fu import ', m.ImportStarUsed, m.UnusedImport) self.flakes(''' try: from fu import except: pass ''', m.ImportStarUsed, m.UnusedImport) checker = self.flakes('from fu import ', m.ImportStarUsed, m.UnusedImport) error = checker.messages[0] assert error.message.startswith("'from %s import ' used; unable ") assert error.message_args == ('fu', ) error = checker.messages[1] assert error.message == '%r imported but unused' assert error.message_args == ('fu.', ) def test_importStar_relative(self): """Use of import from a relative import is reported.""" self.flakes('from .fu import ', m.ImportStarUsed, m.UnusedImport) self.flakes(''' try: from .fu import except: pass ''', m.ImportStarUsed, m.UnusedImport) checker = self.flakes('from .fu import ', m.ImportStarUsed, m.UnusedImport) error = checker.messages[0] assert error.message.startswith("'from %s import ' used; unable ") assert error.message_args == ('.fu', ) error = checker.messages[1] assert error.message == '%r imported but unused' assert error.message_args == ('.fu.', ) checker = self.flakes('from .. import ', m.ImportStarUsed, m.UnusedImport) error = checker.messages[0] assert error.message.startswith("'from %s import ' used; unable ") assert error.message_args == ('..', ) error = checker.messages[1] assert error.message == '%r imported but unused' assert error.message_args == ('from .. import ', ) def test_localImportStar(self): """import * is only allowed at module level.""" self.flakes(''' def a(): from fu import * ''', m.ImportStarNotPermitted) self.flakes(''' class a: from fu import * ''', m.ImportStarNotPermitted) checker = self.flakes(''' class a: from .. import * ''', m.ImportStarNotPermitted) error = checker.messages[0] assert error.message == "'from %s import ' only allowed at module level" assert error.message_args == ('..', ) def test_packageImport(self): """ If a dotted name is imported and used, no warning is reported. """ self.flakes(''' import fu.bar fu.bar ''') def test_unusedPackageImport(self): """ If a dotted name is imported and not used, an unused import warning is reported. """ self.flakes('import fu.bar', m.UnusedImport) def test_duplicateSubmoduleImport(self): """ If a submodule of a package is imported twice, an unused import warning and a redefined while unused warning are reported. """ self.flakes(''' import fu.bar, fu.bar fu.bar ''', m.RedefinedWhileUnused) self.flakes(''' import fu.bar import fu.bar fu.bar ''', m.RedefinedWhileUnused) def test_differentSubmoduleImport(self): """ If two different submodules of a package are imported, no duplicate import warning is reported for the package. """ self.flakes(''' import fu.bar, fu.baz fu.bar, fu.baz ''') self.flakes(''' import fu.bar import fu.baz fu.bar, fu.baz ''') def test_used_package_with_submodule_import(self): """ Usage of package marks submodule imports as used. """ self.flakes(''' import fu import fu.bar fu.x ''') self.flakes(''' import fu.bar import fu fu.x ''') def test_used_package_with_submodule_import_of_alias(self): """ Usage of package by alias marks submodule imports as used. """ self.flakes(''' import foo as f import foo.bar f.bar.do_something() ''') self.flakes(''' import foo as f import foo.bar.blah f.bar.blah.do_something() ''') def test_unused_package_with_submodule_import(self): """ When a package and its submodule are imported, only report once. """ checker = self.flakes(''' import fu import fu.bar ''', m.UnusedImport) error = checker.messages[0] assert error.message == '%r imported but unused' assert error.message_args == ('fu.bar', ) assert error.lineno == 5 if self.withDoctest else 3 def test_assignRHSFirst(self): self.flakes('import fu; fu = fu') self.flakes('import fu; fu, bar = fu') self.flakes('import fu; [fu, bar] = fu') self.flakes('import fu; fu += fu') def test_tryingMultipleImports(self): self.flakes(''' try: import fu except ImportError: import bar as fu fu ''') def test_nonGlobalDoesNotRedefine(self): self.flakes(''' import fu def a(): fu = 3 return fu fu ''') def test_functionsRunLater(self): self.flakes(''' def a(): fu import fu ''') def test_functionNamesAreBoundNow(self): self.flakes(''' import fu def fu(): fu fu ''', m.RedefinedWhileUnused) def test_ignoreNonImportRedefinitions(self): self.flakes('a = 1; a = 2') @skip("todo") def test_importingForImportError(self): self.flakes(''' try: import fu except ImportError: pass ''') def test_importedInClass(self): """Imports in class scope can be used through self.""" self.flakes(''' class c: import i def __init__(self): self.i ''') def test_importUsedInMethodDefinition(self): """ Method named 'foo' with default args referring to module named 'foo'. """ self.flakes(''' import foo class Thing(object): def foo(self, parser=foo.parse_foo): pass ''') def test_futureImport(self): """__future__ is special.""" self.flakes('from __future__ import division') self.flakes(''' "docstring is allowed before future import" from __future__ import division ''') def test_futureImportFirst(self): """ __future__ imports must come before anything else. """ self.flakes(''' x = 5 from __future__ import division ''', m.LateFutureImport) self.flakes(''' from foo import bar from __future__ import division bar ''', m.LateFutureImport) def test_futureImportUsed(self): """__future__ is special, but names are injected in the namespace.""" self.flakes(''' from __future__ import division from __future__ import print_function assert print_function is not division ''') def test_futureImportUndefined(self): """Importing undefined names from __future__ fails.""" self.flakes(''' from __future__ import print_statement ''', m.FutureFeatureNotDefined) def test_futureImportStar(self): """Importing '' from __future__ fails.""" self.flakes(''' from __future__ import * ''', m.FutureFeatureNotDefined) class TestSpecialAll(TestCase): """ Tests for suppression of unused import warnings by C{__all__}. """ def test_ignoredInFunction(self): """ An C{__all__} definition does not suppress unused import warnings in a function scope. """ self.flakes(''' def foo(): import bar __all__ = ["bar"] ''', m.UnusedImport, m.UnusedVariable) def test_ignoredInClass(self): """ An C{__all__} definition in a class does not suppress unused import warnings. """ self.flakes(''' import bar class foo: __all__ = ["bar"] ''', m.UnusedImport) def test_ignored_when_not_directly_assigned(self): self.flakes(''' import bar (__all__,) = ("foo",) ''', m.UnusedImport) def test_warningSuppressed(self): """ If a name is imported and unused but is named in C{__all__}, no warning is reported. """ self.flakes(''' import foo __all__ = ["foo"] ''') self.flakes(''' import foo __all__ = ("foo",) ''') def test_augmentedAssignment(self): """ The C{__all__} variable is defined incrementally. """ self.flakes(''' import a import c __all__ = ['a'] __all__ += ['b'] if 1 < 3: __all__ += ['c', 'd'] ''', m.UndefinedExport, m.UndefinedExport) def test_list_concatenation_assignment(self): """ The C{__all__} variable is defined through list concatenation. """ self.flakes(''' import sys __all__ = ['a'] + ['b'] + ['c'] ''', m.UndefinedExport, m.UndefinedExport, m.UndefinedExport, m.UnusedImport) def test_tuple_concatenation_assignment(self): """ The C{__all__} variable is defined through tuple concatenation. """ self.flakes(''' import sys __all__ = ('a',) + ('b',) + ('c',) ''', m.UndefinedExport, m.UndefinedExport, m.UndefinedExport, m.UnusedImport) def test_all_with_attributes(self): self.flakes(''' from foo import bar __all__ = [bar.__name__] ''') def test_all_with_names(self): # not actually valid, but shouldn't produce a crash self.flakes(''' from foo import bar __all__ = [bar] ''') def test_all_with_attributes_added(self): self.flakes(''' from foo import bar from bar import baz __all__ = [bar.__name__] + [baz.__name__] ''') def test_all_mixed_attributes_and_strings(self): self.flakes(''' from foo import bar from foo import baz __all__ = ['bar', baz.__name__] ''') def test_unboundExported(self): """ If C{__all__} includes a name which is not bound, a warning is emitted. """ self.flakes(''' __all__ = ["foo"] ''', m.UndefinedExport) # Skip this in __init__.py though, since the rules there are a little # different. for filename in ["foo/__init__.py", "__init__.py"]: self.flakes(''' __all__ = ["foo"] ''', filename=filename) def test_importStarExported(self): """ Report undefined if import * is used """ self.flakes(''' from math import * __all__ = ['sin', 'cos'] csc(1) ''', m.ImportStarUsed, m.ImportStarUsage, m.ImportStarUsage, m.ImportStarUsage) def test_importStarNotExported(self): """Report unused import when not needed to satisfy __all__.""" self.flakes(''' from foolib import * a = 1 __all__ = ['a'] ''', m.ImportStarUsed, m.UnusedImport) def test_usedInGenExp(self): """ Using a global in a generator expression results in no warnings. """ self.flakes('import fu; (fu for _ in range(1))') self.flakes('import fu; (1 for _ in range(1) if fu)') def test_redefinedByGenExp(self): """ Re-using a global name as the loop variable for a generator expression results in a redefinition warning. """ self.flakes('import fu; (1 for fu in range(1))', m.RedefinedWhileUnused, m.UnusedImport) def test_usedAsDecorator(self): """ 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. """ self.flakes(''' from interior import decorate @decorate def f(): return "hello" ''') self.flakes(''' from interior import decorate @decorate('value') def f(): return "hello" ''') self.flakes(''' @decorate def f(): return "hello" ''', m.UndefinedName) def test_usedAsClassDecorator(self): """ 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. """ self.flakes(''' from interior import decorate @decorate class foo: pass ''') self.flakes(''' from interior import decorate @decorate("foo") class bar: pass ''') self.flakes(''' @decorate class foo: pass ''', m.UndefinedName)	32.91 KB	2026-01-20 12:58
📄 test_is_literal.py from pyflakes.messages import IsLiteral from pyflakes.test.harness import TestCase class Test(TestCase): def test_is_str(self): self.flakes(""" x = 'foo' if x is 'foo': pass """, IsLiteral) def test_is_bytes(self): self.flakes(""" x = b'foo' if x is b'foo': pass """, IsLiteral) def test_is_unicode(self): self.flakes(""" x = u'foo' if x is u'foo': pass """, IsLiteral) def test_is_int(self): self.flakes(""" x = 10 if x is 10: pass """, IsLiteral) def test_is_true(self): self.flakes(""" x = True if x is True: pass """) def test_is_false(self): self.flakes(""" x = False if x is False: pass """) def test_is_not_str(self): self.flakes(""" x = 'foo' if x is not 'foo': pass """, IsLiteral) def test_is_not_bytes(self): self.flakes(""" x = b'foo' if x is not b'foo': pass """, IsLiteral) def test_is_not_unicode(self): self.flakes(""" x = u'foo' if x is not u'foo': pass """, IsLiteral) def test_is_not_int(self): self.flakes(""" x = 10 if x is not 10: pass """, IsLiteral) def test_is_not_true(self): self.flakes(""" x = True if x is not True: pass """) def test_is_not_false(self): self.flakes(""" x = False if x is not False: pass """) def test_left_is_str(self): self.flakes(""" x = 'foo' if 'foo' is x: pass """, IsLiteral) def test_left_is_bytes(self): self.flakes(""" x = b'foo' if b'foo' is x: pass """, IsLiteral) def test_left_is_unicode(self): self.flakes(""" x = u'foo' if u'foo' is x: pass """, IsLiteral) def test_left_is_int(self): self.flakes(""" x = 10 if 10 is x: pass """, IsLiteral) def test_left_is_true(self): self.flakes(""" x = True if True is x: pass """) def test_left_is_false(self): self.flakes(""" x = False if False is x: pass """) def test_left_is_not_str(self): self.flakes(""" x = 'foo' if 'foo' is not x: pass """, IsLiteral) def test_left_is_not_bytes(self): self.flakes(""" x = b'foo' if b'foo' is not x: pass """, IsLiteral) def test_left_is_not_unicode(self): self.flakes(""" x = u'foo' if u'foo' is not x: pass """, IsLiteral) def test_left_is_not_int(self): self.flakes(""" x = 10 if 10 is not x: pass """, IsLiteral) def test_left_is_not_true(self): self.flakes(""" x = True if True is not x: pass """) def test_left_is_not_false(self): self.flakes(""" x = False if False is not x: pass """) def test_chained_operators_is_true(self): self.flakes(""" x = 5 if x is True < 4: pass """) def test_chained_operators_is_str(self): self.flakes(""" x = 5 if x is 'foo' < 4: pass """, IsLiteral) def test_chained_operators_is_true_end(self): self.flakes(""" x = 5 if 4 < x is True: pass """) def test_chained_operators_is_str_end(self): self.flakes(""" x = 5 if 4 < x is 'foo': pass """, IsLiteral) def test_is_tuple_constant(self): self.flakes('''\ x = 5 if x is (): pass ''', IsLiteral) def test_is_tuple_constant_containing_constants(self): self.flakes('''\ x = 5 if x is (1, '2', True, (1.5, ())): pass ''', IsLiteral) def test_is_tuple_containing_variables_ok(self): # a bit nonsensical, but does not trigger a SyntaxWarning self.flakes('''\ x = 5 if x is (x,): pass ''')	4.47 KB	2026-01-20 12:58
📄 test_match.py from sys import version_info from pyflakes.test.harness import TestCase, skipIf @skipIf(version_info < (3, 10), "Python >= 3.10 only") class TestMatch(TestCase): def test_match_bindings(self): self.flakes(''' def f(): x = 1 match x: case 1 as y: print(f'matched as {y}') ''') self.flakes(''' def f(): x = [1, 2, 3] match x: case [1, y, 3]: print(f'matched {y}') ''') self.flakes(''' def f(): x = {'foo': 1} match x: case {'foo': y}: print(f'matched {y}') ''') def test_match_pattern_matched_class(self): self.flakes(''' from a import B match 1: case B(x=1) as y: print(f'matched {y}') ''') self.flakes(''' from a import B match 1: case B(a, x=z) as y: print(f'matched {y} {a} {z}') ''') def test_match_placeholder(self): self.flakes(''' def f(): match 1: case _: print('catchall!') ''') def test_match_singleton(self): self.flakes(''' match 1: case True: print('true') ''') def test_match_or_pattern(self): self.flakes(''' match 1: case 1 \| 2: print('one or two') ''') def test_match_star(self): self.flakes(''' x = [1, 2, 3] match x: case [1, y]: print(f'captured: {y}') ''') def test_match_double_star(self): self.flakes(''' x = {'foo': 'bar', 'baz': 'womp'} match x: case {'foo': k1, *rest}: print(f'{k1=} {rest=}') ''')	2.05 KB	2026-01-20 12:58
📄 test_other.py """ Tests for various Pyflakes behavior. """ from sys import version_info from pyflakes import messages as m from pyflakes.test.harness import TestCase, skip, skipIf class Test(TestCase): def test_duplicateArgs(self): self.flakes('def fu(bar, bar): pass', m.DuplicateArgument) def test_localReferencedBeforeAssignment(self): self.flakes(''' a = 1 def f(): a; a=1 f() ''', m.UndefinedLocal, m.UnusedVariable) def test_redefinedInGenerator(self): """ Test that reusing a variable in a generator does not raise a warning. """ self.flakes(''' a = 1 (1 for a, b in [(1, 2)]) ''') self.flakes(''' class A: a = 1 list(1 for a, b in [(1, 2)]) ''') self.flakes(''' def f(): a = 1 (1 for a, b in [(1, 2)]) ''', m.UnusedVariable) self.flakes(''' (1 for a, b in [(1, 2)]) (1 for a, b in [(1, 2)]) ''') self.flakes(''' for a, b in [(1, 2)]: pass (1 for a, b in [(1, 2)]) ''') def test_redefinedInSetComprehension(self): """ Test that reusing a variable in a set comprehension does not raise a warning. """ self.flakes(''' a = 1 {1 for a, b in [(1, 2)]} ''') self.flakes(''' class A: a = 1 {1 for a, b in [(1, 2)]} ''') self.flakes(''' def f(): a = 1 {1 for a, b in [(1, 2)]} ''', m.UnusedVariable) self.flakes(''' {1 for a, b in [(1, 2)]} {1 for a, b in [(1, 2)]} ''') self.flakes(''' for a, b in [(1, 2)]: pass {1 for a, b in [(1, 2)]} ''') def test_redefinedInDictComprehension(self): """ Test that reusing a variable in a dict comprehension does not raise a warning. """ self.flakes(''' a = 1 {1: 42 for a, b in [(1, 2)]} ''') self.flakes(''' class A: a = 1 {1: 42 for a, b in [(1, 2)]} ''') self.flakes(''' def f(): a = 1 {1: 42 for a, b in [(1, 2)]} ''', m.UnusedVariable) self.flakes(''' {1: 42 for a, b in [(1, 2)]} {1: 42 for a, b in [(1, 2)]} ''') self.flakes(''' for a, b in [(1, 2)]: pass {1: 42 for a, b in [(1, 2)]} ''') def test_redefinedFunction(self): """ Test that shadowing a function definition with another one raises a warning. """ self.flakes(''' def a(): pass def a(): pass ''', m.RedefinedWhileUnused) def test_redefinedUnderscoreFunction(self): """ Test that shadowing a function definition named with underscore doesn't raise anything. """ self.flakes(''' def _(): pass def _(): pass ''') def test_redefinedUnderscoreImportation(self): """ Test that shadowing an underscore importation raises a warning. """ self.flakes(''' from .i18n import _ def _(): pass ''', m.RedefinedWhileUnused) def test_redefinedClassFunction(self): """ Test that shadowing a function definition in a class suite with another one raises a warning. """ self.flakes(''' class A: def a(): pass def a(): pass ''', m.RedefinedWhileUnused) def test_redefinedIfElseFunction(self): """ Test that shadowing a function definition twice in an if and else block does not raise a warning. """ self.flakes(''' if True: def a(): pass else: def a(): pass ''') def test_redefinedIfFunction(self): """ Test that shadowing a function definition within an if block raises a warning. """ self.flakes(''' if True: def a(): pass def a(): pass ''', m.RedefinedWhileUnused) def test_redefinedTryExceptFunction(self): """ Test that shadowing a function definition twice in try and except block does not raise a warning. """ self.flakes(''' try: def a(): pass except: def a(): pass ''') def test_redefinedTryFunction(self): """ Test that shadowing a function definition within a try block raises a warning. """ self.flakes(''' try: def a(): pass def a(): pass except: pass ''', m.RedefinedWhileUnused) def test_redefinedIfElseInListComp(self): """ Test that shadowing a variable in a list comprehension in an if and else block does not raise a warning. """ self.flakes(''' if False: a = 1 else: [a for a in '12'] ''') def test_functionDecorator(self): """ Test that shadowing a function definition with a decorated version of that function does not raise a warning. """ self.flakes(''' from somewhere import somedecorator def a(): pass a = somedecorator(a) ''') def test_classFunctionDecorator(self): """ Test that shadowing a function definition in a class suite with a decorated version of that function does not raise a warning. """ self.flakes(''' class A: def a(): pass a = classmethod(a) ''') def test_modernProperty(self): self.flakes(""" class A: @property def t(self): pass @t.setter def t(self, value): pass @t.deleter def t(self): pass """) def test_unaryPlus(self): """Don't die on unary +.""" self.flakes('+1') def test_undefinedBaseClass(self): """ If a name in the base list of a class definition is undefined, a warning is emitted. """ self.flakes(''' class foo(foo): pass ''', m.UndefinedName) def test_classNameUndefinedInClassBody(self): """ If a class name is used in the body of that class's definition and the name is not already defined, a warning is emitted. """ self.flakes(''' class foo: foo ''', m.UndefinedName) def test_classNameDefinedPreviously(self): """ If a class name is used in the body of that class's definition and the name was previously defined in some other way, no warning is emitted. """ self.flakes(''' foo = None class foo: foo ''') def test_classRedefinition(self): """ If a class is defined twice in the same module, a warning is emitted. """ self.flakes(''' class Foo: pass class Foo: pass ''', m.RedefinedWhileUnused) def test_functionRedefinedAsClass(self): """ If a function is redefined as a class, a warning is emitted. """ self.flakes(''' def Foo(): pass class Foo: pass ''', m.RedefinedWhileUnused) def test_classRedefinedAsFunction(self): """ If a class is redefined as a function, a warning is emitted. """ self.flakes(''' class Foo: pass def Foo(): pass ''', m.RedefinedWhileUnused) def test_classWithReturn(self): """ If a return is used inside a class, a warning is emitted. """ self.flakes(''' class Foo(object): return ''', m.ReturnOutsideFunction) def test_moduleWithReturn(self): """ If a return is used at the module level, a warning is emitted. """ self.flakes(''' return ''', m.ReturnOutsideFunction) def test_classWithYield(self): """ If a yield is used inside a class, a warning is emitted. """ self.flakes(''' class Foo(object): yield ''', m.YieldOutsideFunction) def test_moduleWithYield(self): """ If a yield is used at the module level, a warning is emitted. """ self.flakes(''' yield ''', m.YieldOutsideFunction) def test_classWithYieldFrom(self): """ If a yield from is used inside a class, a warning is emitted. """ self.flakes(''' class Foo(object): yield from range(10) ''', m.YieldOutsideFunction) def test_moduleWithYieldFrom(self): """ If a yield from is used at the module level, a warning is emitted. """ self.flakes(''' yield from range(10) ''', m.YieldOutsideFunction) def test_continueOutsideLoop(self): self.flakes(''' continue ''', m.ContinueOutsideLoop) self.flakes(''' def f(): continue ''', m.ContinueOutsideLoop) self.flakes(''' while True: pass else: continue ''', m.ContinueOutsideLoop) self.flakes(''' while True: pass else: if 1: if 2: continue ''', m.ContinueOutsideLoop) self.flakes(''' while True: def f(): continue ''', m.ContinueOutsideLoop) self.flakes(''' while True: class A: continue ''', m.ContinueOutsideLoop) def test_continueInsideLoop(self): self.flakes(''' while True: continue ''') self.flakes(''' for i in range(10): continue ''') self.flakes(''' while True: if 1: continue ''') self.flakes(''' for i in range(10): if 1: continue ''') self.flakes(''' while True: while True: pass else: continue else: pass ''') self.flakes(''' while True: try: pass finally: while True: continue ''') @skipIf(version_info > (3, 8), "Python <= 3.8 only") def test_continueInFinally(self): # 'continue' inside 'finally' is a special syntax error # that is removed in 3.8 self.flakes(''' while True: try: pass finally: continue ''', m.ContinueInFinally) self.flakes(''' while True: try: pass finally: if 1: if 2: continue ''', m.ContinueInFinally) # Even when not in a loop, this is the error Python gives self.flakes(''' try: pass finally: continue ''', m.ContinueInFinally) def test_breakOutsideLoop(self): self.flakes(''' break ''', m.BreakOutsideLoop) self.flakes(''' def f(): break ''', m.BreakOutsideLoop) self.flakes(''' while True: pass else: break ''', m.BreakOutsideLoop) self.flakes(''' while True: pass else: if 1: if 2: break ''', m.BreakOutsideLoop) self.flakes(''' while True: def f(): break ''', m.BreakOutsideLoop) self.flakes(''' while True: class A: break ''', m.BreakOutsideLoop) self.flakes(''' try: pass finally: break ''', m.BreakOutsideLoop) def test_breakInsideLoop(self): self.flakes(''' while True: break ''') self.flakes(''' for i in range(10): break ''') self.flakes(''' while True: if 1: break ''') self.flakes(''' for i in range(10): if 1: break ''') self.flakes(''' while True: while True: pass else: break else: pass ''') self.flakes(''' while True: try: pass finally: while True: break ''') self.flakes(''' while True: try: pass finally: break ''') self.flakes(''' while True: try: pass finally: if 1: if 2: break ''') def test_defaultExceptLast(self): """ A default except block should be last. YES: try: ... except Exception: ... except: ... NO: try: ... except: ... except Exception: ... """ self.flakes(''' try: pass except ValueError: pass ''') self.flakes(''' try: pass except ValueError: pass except: pass ''') self.flakes(''' try: pass except: pass ''') self.flakes(''' try: pass except ValueError: pass else: pass ''') self.flakes(''' try: pass except: pass else: pass ''') self.flakes(''' try: pass except ValueError: pass except: pass else: pass ''') def test_defaultExceptNotLast(self): self.flakes(''' try: pass except: pass except ValueError: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass except: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass except: pass except ValueError: pass ''', m.DefaultExceptNotLast, m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass else: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except: pass else: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass except: pass else: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass except: pass except ValueError: pass else: pass ''', m.DefaultExceptNotLast, m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass finally: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except: pass finally: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass except: pass finally: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass except: pass except ValueError: pass finally: pass ''', m.DefaultExceptNotLast, m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass else: pass finally: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except: pass else: pass finally: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass except: pass else: pass finally: pass ''', m.DefaultExceptNotLast) self.flakes(''' try: pass except: pass except ValueError: pass except: pass except ValueError: pass else: pass finally: pass ''', m.DefaultExceptNotLast, m.DefaultExceptNotLast) def test_starredAssignmentNoError(self): """ Python 3 extended iterable unpacking """ self.flakes(''' a, b = range(10) ''') self.flakes(''' a, b = range(10) ''') self.flakes(''' a, b, c = range(10) ''') self.flakes(''' (a, b) = range(10) ''') self.flakes(''' (a, b) = range(10) ''') self.flakes(''' (a, b, c) = range(10) ''') self.flakes(''' [a, b] = range(10) ''') self.flakes(''' [a, b] = range(10) ''') self.flakes(''' [a, b, c] = range(10) ''') # Taken from test_unpack_ex.py in the cPython source s = ", ".join("a%d" % i for i in range(1 << 8 - 1)) + \ ", rest = range(1<<8)" self.flakes(s) s = "(" + ", ".join("a%d" % i for i in range(1 << 8 - 1)) + \ ", rest) = range(1<<8)" self.flakes(s) s = "[" + ", ".join("a%d" % i for i in range(1 << 8 - 1)) + \ ", rest] = range(1<<8)" self.flakes(s) def test_starredAssignmentErrors(self): """ SyntaxErrors (not encoded in the ast) surrounding Python 3 extended iterable unpacking """ # Taken from test_unpack_ex.py in the cPython source s = ", ".join("a%d" % i for i in range(1 << 8)) + \ ", rest = range(1<<8 + 1)" self.flakes(s, m.TooManyExpressionsInStarredAssignment) s = "(" + ", ".join("a%d" % i for i in range(1 << 8)) + \ ", rest) = range(1<<8 + 1)" self.flakes(s, m.TooManyExpressionsInStarredAssignment) s = "[" + ", ".join("a%d" % i for i in range(1 << 8)) + \ ", rest] = range(1<<8 + 1)" self.flakes(s, m.TooManyExpressionsInStarredAssignment) s = ", ".join("a%d" % i for i in range(1 << 8 + 1)) + \ ", rest = range(1<<8 + 2)" self.flakes(s, m.TooManyExpressionsInStarredAssignment) s = "(" + ", ".join("a%d" % i for i in range(1 << 8 + 1)) + \ ", rest) = range(1<<8 + 2)" self.flakes(s, m.TooManyExpressionsInStarredAssignment) s = "[" + ", ".join("a%d" % i for i in range(1 << 8 + 1)) + \ ", rest] = range(1<<8 + 2)" self.flakes(s, m.TooManyExpressionsInStarredAssignment) # No way we can actually test this! # s = "rest, " + ", ".join("a%d" % i for i in range(1<<24)) + \ # ", rest = range(1<<24 + 1)" # self.flakes(s, m.TooManyExpressionsInStarredAssignment) self.flakes(''' a, b, c = range(10) ''', m.TwoStarredExpressions) self.flakes(''' a, b, c, d = range(10) ''', m.TwoStarredExpressions) self.flakes(''' a, b, c = range(10) ''', m.TwoStarredExpressions) self.flakes(''' (a, b, c) = range(10) ''', m.TwoStarredExpressions) self.flakes(''' (a, b, c, d) = range(10) ''', m.TwoStarredExpressions) self.flakes(''' (a, b, c) = range(10) ''', m.TwoStarredExpressions) self.flakes(''' [a, b, c] = range(10) ''', m.TwoStarredExpressions) self.flakes(''' [a, b, c, d] = range(10) ''', m.TwoStarredExpressions) self.flakes(''' [a, b, c] = range(10) ''', m.TwoStarredExpressions) @skip("todo: Too hard to make this warn but other cases stay silent") def test_doubleAssignment(self): """ If a variable is re-assigned to without being used, no warning is emitted. """ self.flakes(''' x = 10 x = 20 ''', m.RedefinedWhileUnused) def test_doubleAssignmentConditionally(self): """ If a variable is re-assigned within a conditional, no warning is emitted. """ self.flakes(''' x = 10 if True: x = 20 ''') def test_doubleAssignmentWithUse(self): """ If a variable is re-assigned to after being used, no warning is emitted. """ self.flakes(''' x = 10 y = x 2 x = 20 ''') def test_comparison(self): """ If a defined name is used on either side of any of the six comparison operators, no warning is emitted. """ self.flakes(''' x = 10 y = 20 x < y x <= y x == y x != y x >= y x > y ''') def test_identity(self): """ If a defined name is used on either side of an identity test, no warning is emitted. """ self.flakes(''' x = 10 y = 20 x is y x is not y ''') def test_containment(self): """ If a defined name is used on either side of a containment test, no warning is emitted. """ self.flakes(''' x = 10 y = 20 x in y x not in y ''') def test_loopControl(self): """ break and continue statements are supported. """ self.flakes(''' for x in [1, 2]: break ''') self.flakes(''' for x in [1, 2]: continue ''') def test_ellipsis(self): """ Ellipsis in a slice is supported. """ self.flakes(''' [1, 2][...] ''') def test_extendedSlice(self): """ Extended slices are supported. """ self.flakes(''' x = 3 [1, 2][x,:] ''') def test_varAugmentedAssignment(self): """ Augmented assignment of a variable is supported. We don't care about var refs. """ self.flakes(''' foo = 0 foo += 1 ''') def test_attrAugmentedAssignment(self): """ Augmented assignment of attributes is supported. We don't care about attr refs. """ self.flakes(''' foo = None foo.bar += foo.baz ''') def test_globalDeclaredInDifferentScope(self): """ A 'global' can be declared in one scope and reused in another. """ self.flakes(''' def f(): global foo def g(): foo = 'anything'; foo.is_used() ''') def test_function_arguments(self): """ Test to traverse ARG and ARGUMENT handler """ self.flakes(''' def foo(a, b): pass ''') self.flakes(''' def foo(a, b, c=0): pass ''') self.flakes(''' def foo(a, b, c=0, args): pass ''') self.flakes(''' def foo(a, b, c=0, args, *kwargs): pass ''') def test_function_arguments_python3(self): self.flakes(''' def foo(a, b, c=0, args, d=0, *kwargs): pass ''') class TestUnusedAssignment(TestCase): """ Tests for warning about unused assignments. """ def test_unusedVariable(self): """ Warn when a variable in a function is assigned a value that's never used. """ self.flakes(''' def a(): b = 1 ''', m.UnusedVariable) def test_unusedUnderscoreVariable(self): """ Don't warn when the magic "_" (underscore) variable is unused. See issue #202. """ self.flakes(''' def a(unused_param): _ = unused_param ''') def test_unusedVariableAsLocals(self): """ Using locals() it is perfectly valid to have unused variables """ self.flakes(''' def a(): b = 1 return locals() ''') def test_unusedVariableNoLocals(self): """ Using locals() in wrong scope should not matter """ self.flakes(''' def a(): locals() def a(): b = 1 return ''', m.UnusedVariable) @skip("todo: Difficult because it doesn't apply in the context of a loop") def test_unusedReassignedVariable(self): """ Shadowing a used variable can still raise an UnusedVariable warning. """ self.flakes(''' def a(): b = 1 b.foo() b = 2 ''', m.UnusedVariable) def test_variableUsedInLoop(self): """ Shadowing a used variable cannot raise an UnusedVariable warning in the context of a loop. """ self.flakes(''' def a(): b = True while b: b = False ''') def test_assignToGlobal(self): """ Assigning to a global and then not using that global is perfectly acceptable. Do not mistake it for an unused local variable. """ self.flakes(''' b = 0 def a(): global b b = 1 ''') def test_assignToNonlocal(self): """ Assigning to a nonlocal and then not using that binding is perfectly acceptable. Do not mistake it for an unused local variable. """ self.flakes(''' b = b'0' def a(): nonlocal b b = b'1' ''') def test_assignToMember(self): """ Assigning to a member of another object and then not using that member variable is perfectly acceptable. Do not mistake it for an unused local variable. """ # XXX: Adding this test didn't generate a failure. Maybe not # necessary? self.flakes(''' class b: pass def a(): b.foo = 1 ''') def test_assignInForLoop(self): """ Don't warn when a variable in a for loop is assigned to but not used. """ self.flakes(''' def f(): for i in range(10): pass ''') def test_assignInListComprehension(self): """ Don't warn when a variable in a list comprehension is assigned to but not used. """ self.flakes(''' def f(): [None for i in range(10)] ''') def test_generatorExpression(self): """ Don't warn when a variable in a generator expression is assigned to but not used. """ self.flakes(''' def f(): (None for i in range(10)) ''') def test_assignmentInsideLoop(self): """ Don't warn when a variable assignment occurs lexically after its use. """ self.flakes(''' def f(): x = None for i in range(10): if i > 2: return x x = i 2 ''') def test_tupleUnpacking(self): """ Don't warn when a variable included in tuple unpacking is unused. It's very common for variables in a tuple unpacking assignment to be unused in good Python code, so warning will only create false positives. """ self.flakes(''' def f(tup): (x, y) = tup ''') self.flakes(''' def f(): (x, y) = 1, 2 ''', m.UnusedVariable, m.UnusedVariable) self.flakes(''' def f(): (x, y) = coords = 1, 2 if x > 1: print(coords) ''') self.flakes(''' def f(): (x, y) = coords = 1, 2 ''', m.UnusedVariable) self.flakes(''' def f(): coords = (x, y) = 1, 2 ''', m.UnusedVariable) def test_listUnpacking(self): """ Don't warn when a variable included in list unpacking is unused. """ self.flakes(''' def f(tup): [x, y] = tup ''') self.flakes(''' def f(): [x, y] = [1, 2] ''', m.UnusedVariable, m.UnusedVariable) def test_closedOver(self): """ Don't warn when the assignment is used in an inner function. """ self.flakes(''' def barMaker(): foo = 5 def bar(): return foo return bar ''') def test_doubleClosedOver(self): """ Don't warn when the assignment is used in an inner function, even if that inner function itself is in an inner function. """ self.flakes(''' def barMaker(): foo = 5 def bar(): def baz(): return foo return bar ''') def test_tracebackhideSpecialVariable(self): """ Do not warn about unused local variable __tracebackhide__, which is a special variable for py.test. """ self.flakes(""" def helper(): __tracebackhide__ = True """) def test_ifexp(self): """ Test C{foo if bar else baz} statements. """ self.flakes("a = 'moo' if True else 'oink'") self.flakes("a = foo if True else 'oink'", m.UndefinedName) self.flakes("a = 'moo' if True else bar", m.UndefinedName) def test_if_tuple(self): """ Test C{if (foo,)} conditions. """ self.flakes("""if (): pass""") self.flakes(""" if ( True ): pass """) self.flakes(""" if ( True, ): pass """, m.IfTuple) self.flakes(""" x = 1 if ( True, ) else 2 """, m.IfTuple) def test_withStatementNoNames(self): """ No warnings are emitted for using inside or after a nameless C{with} statement a name defined beforehand. """ self.flakes(''' bar = None with open("foo"): bar bar ''') def test_withStatementSingleName(self): """ No warnings are emitted for using a name defined by a C{with} statement within the suite or afterwards. """ self.flakes(''' with open('foo') as bar: bar bar ''') def test_withStatementAttributeName(self): """ No warnings are emitted for using an attribute as the target of a C{with} statement. """ self.flakes(''' import foo with open('foo') as foo.bar: pass ''') def test_withStatementSubscript(self): """ No warnings are emitted for using a subscript as the target of a C{with} statement. """ self.flakes(''' import foo with open('foo') as foo[0]: pass ''') def test_withStatementSubscriptUndefined(self): """ An undefined name warning is emitted if the subscript used as the target of a C{with} statement is not defined. """ self.flakes(''' import foo with open('foo') as foo[bar]: pass ''', m.UndefinedName) def test_withStatementTupleNames(self): """ No warnings are emitted for using any of the tuple of names defined by a C{with} statement within the suite or afterwards. """ self.flakes(''' with open('foo') as (bar, baz): bar, baz bar, baz ''') def test_withStatementListNames(self): """ No warnings are emitted for using any of the list of names defined by a C{with} statement within the suite or afterwards. """ self.flakes(''' with open('foo') as [bar, baz]: bar, baz bar, baz ''') def test_withStatementComplicatedTarget(self): """ If the target of a C{with} statement uses any or all of the valid forms for that part of the grammar (See U{http://docs.python.org/reference/compound_stmts.html#the-with-statement}), the names involved are checked both for definedness and any bindings created are respected in the suite of the statement and afterwards. """ self.flakes(''' c = d = e = g = h = i = None with open('foo') as [(a, b), c[d], e.f, g[h:i]]: a, b, c, d, e, g, h, i a, b, c, d, e, g, h, i ''') def test_withStatementSingleNameUndefined(self): """ An undefined name warning is emitted if the name first defined by a C{with} statement is used before the C{with} statement. """ self.flakes(''' bar with open('foo') as bar: pass ''', m.UndefinedName) def test_withStatementTupleNamesUndefined(self): """ An undefined name warning is emitted if a name first defined by the tuple-unpacking form of the C{with} statement is used before the C{with} statement. """ self.flakes(''' baz with open('foo') as (bar, baz): pass ''', m.UndefinedName) def test_withStatementSingleNameRedefined(self): """ A redefined name warning is emitted if a name bound by an import is rebound by the name defined by a C{with} statement. """ self.flakes(''' import bar with open('foo') as bar: pass ''', m.RedefinedWhileUnused) def test_withStatementTupleNamesRedefined(self): """ A redefined name warning is emitted if a name bound by an import is rebound by one of the names defined by the tuple-unpacking form of a C{with} statement. """ self.flakes(''' import bar with open('foo') as (bar, baz): pass ''', m.RedefinedWhileUnused) def test_withStatementUndefinedInside(self): """ An undefined name warning is emitted if a name is used inside the body of a C{with} statement without first being bound. """ self.flakes(''' with open('foo') as bar: baz ''', m.UndefinedName) def test_withStatementNameDefinedInBody(self): """ A name defined in the body of a C{with} statement can be used after the body ends without warning. """ self.flakes(''' with open('foo') as bar: baz = 10 baz ''') def test_withStatementUndefinedInExpression(self): """ An undefined name warning is emitted if a name in the I{test} expression of a C{with} statement is undefined. """ self.flakes(''' with bar as baz: pass ''', m.UndefinedName) self.flakes(''' with bar as bar: pass ''', m.UndefinedName) def test_dictComprehension(self): """ Dict comprehensions are properly handled. """ self.flakes(''' a = {1: x for x in range(10)} ''') def test_setComprehensionAndLiteral(self): """ Set comprehensions are properly handled. """ self.flakes(''' a = {1, 2, 3} b = {x for x in range(10)} ''') def test_exceptionUsedInExcept(self): self.flakes(''' try: pass except Exception as e: e ''') self.flakes(''' def download_review(): try: pass except Exception as e: e ''') def test_exceptionUnusedInExcept(self): self.flakes(''' try: pass except Exception as e: pass ''', m.UnusedVariable) @skipIf(version_info < (3, 11), 'new in Python 3.11') def test_exception_unused_in_except_star(self): self.flakes(''' try: pass except* OSError as e: pass ''', m.UnusedVariable) def test_exceptionUnusedInExceptInFunction(self): self.flakes(''' def download_review(): try: pass except Exception as e: pass ''', m.UnusedVariable) def test_exceptWithoutNameInFunction(self): """ Don't issue false warning when an unnamed exception is used. Previously, there would be a false warning, but only when the try..except was in a function """ self.flakes(''' import tokenize def foo(): try: pass except tokenize.TokenError: pass ''') def test_exceptWithoutNameInFunctionTuple(self): """ Don't issue false warning when an unnamed exception is used. This example catches a tuple of exception types. """ self.flakes(''' import tokenize def foo(): try: pass except (tokenize.TokenError, IndentationError): pass ''') def test_augmentedAssignmentImportedFunctionCall(self): """ Consider a function that is called on the right part of an augassign operation to be used. """ self.flakes(''' from foo import bar baz = 0 baz += bar() ''') def test_assert_without_message(self): """An assert without a message is not an error.""" self.flakes(''' a = 1 assert a ''') def test_assert_with_message(self): """An assert with a message is not an error.""" self.flakes(''' a = 1 assert a, 'x' ''') def test_assert_tuple(self): """An assert of a non-empty tuple is always True.""" self.flakes(''' assert (False, 'x') assert (False, ) ''', m.AssertTuple, m.AssertTuple) def test_assert_tuple_empty(self): """An assert of an empty tuple is always False.""" self.flakes(''' assert () ''') def test_assert_static(self): """An assert of a static value is not an error.""" self.flakes(''' assert True assert 1 ''') def test_yieldFromUndefined(self): """ Test C{yield from} statement """ self.flakes(''' def bar(): yield from foo() ''', m.UndefinedName) def test_f_string(self): """Test PEP 498 f-strings are treated as a usage.""" self.flakes(''' baz = 0 print(f'\x7b4baz\N{RIGHT CURLY BRACKET}') ''') @skipIf(version_info < (3, 8), 'new in Python 3.8') def test_assign_expr(self): """Test PEP 572 assignment expressions are treated as usage / write.""" self.flakes(''' from foo import y print(x := y) print(x) ''') @skipIf(version_info < (3, 8), 'new in Python 3.8') def test_assign_expr_generator_scope(self): """Test assignment expressions in generator expressions.""" self.flakes(''' if (any((y := x[0]) for x in [[True]])): print(y) ''') @skipIf(version_info < (3, 8), 'new in Python 3.8') def test_assign_expr_nested(self): """Test assignment expressions in nested expressions.""" self.flakes(''' if ([(y:=x) for x in range(4) if [(z:=q) for q in range(4)]]): print(y) print(z) ''') class TestStringFormatting(TestCase): def test_f_string_without_placeholders(self): self.flakes("f'foo'", m.FStringMissingPlaceholders) self.flakes(''' f"""foo bar """ ''', m.FStringMissingPlaceholders) self.flakes(''' print( f'foo' f'bar' ) ''', m.FStringMissingPlaceholders) # this is an "escaped placeholder" but not a placeholder self.flakes("f'{{}}'", m.FStringMissingPlaceholders) # ok: f-string with placeholders self.flakes(''' x = 5 print(f'{x}') ''') # ok: f-string with format specifiers self.flakes(''' x = 'a' 90 print(f'{x:.8}') ''') # ok: f-string with multiple format specifiers self.flakes(''' x = y = 5 print(f'{x:>2} {y:>2}') ''') def test_invalid_dot_format_calls(self): self.flakes(''' '{'.format(1) ''', m.StringDotFormatInvalidFormat) self.flakes(''' '{} {1}'.format(1, 2) ''', m.StringDotFormatMixingAutomatic) self.flakes(''' '{0} {}'.format(1, 2) ''', m.StringDotFormatMixingAutomatic) self.flakes(''' '{}'.format(1, 2) ''', m.StringDotFormatExtraPositionalArguments) self.flakes(''' '{}'.format(1, bar=2) ''', m.StringDotFormatExtraNamedArguments) self.flakes(''' '{} {}'.format(1) ''', m.StringDotFormatMissingArgument) self.flakes(''' '{2}'.format() ''', m.StringDotFormatMissingArgument) self.flakes(''' '{bar}'.format() ''', m.StringDotFormatMissingArgument) # too much string recursion (placeholder-in-placeholder) self.flakes(''' '{:{:{}}}'.format(1, 2, 3) ''', m.StringDotFormatInvalidFormat) # ok: dotted / bracketed names need to handle the param differently self.flakes("'{.__class__}'.format('')") self.flakes("'{foo[bar]}'.format(foo={'bar': 'barv'})") # ok: placeholder-placeholders self.flakes(''' print('{:{}} {}'.format(1, 15, 2)) ''') # ok: not a placeholder-placeholder self.flakes(''' print('{:2}'.format(1)) ''') # ok: not mixed automatic self.flakes(''' '{foo}-{}'.format(1, foo=2) ''') # ok: we can't determine statically the format args self.flakes(''' a = () "{}".format(a) ''') self.flakes(''' k = {} "{foo}".format(k) ''') def test_invalid_percent_format_calls(self): self.flakes(''' '%(foo)' % {'foo': 'bar'} ''', m.PercentFormatInvalidFormat) self.flakes(''' '%s %(foo)s' % {'foo': 'bar'} ''', m.PercentFormatMixedPositionalAndNamed) self.flakes(''' '%(foo)s %s' % {'foo': 'bar'} ''', m.PercentFormatMixedPositionalAndNamed) self.flakes(''' '%j' % (1,) ''', m.PercentFormatUnsupportedFormatCharacter) self.flakes(''' '%s %s' % (1,) ''', m.PercentFormatPositionalCountMismatch) self.flakes(''' '%s %s' % (1, 2, 3) ''', m.PercentFormatPositionalCountMismatch) self.flakes(''' '%(bar)s' % {} ''', m.PercentFormatMissingArgument,) self.flakes(''' '%(bar)s' % {'bar': 1, 'baz': 2} ''', m.PercentFormatExtraNamedArguments) self.flakes(''' '%(bar)s' % (1, 2, 3) ''', m.PercentFormatExpectedMapping) self.flakes(''' '%s %s' % {'k': 'v'} ''', m.PercentFormatExpectedSequence) self.flakes(''' '%(bar)s' % {'bar': 'baz'} ''', m.PercentFormatStarRequiresSequence) # ok: single %s with mapping self.flakes(''' '%s' % {'foo': 'bar', 'baz': 'womp'} ''') # ok: does not cause a MemoryError (the strings aren't evaluated) self.flakes(''' "%1000000000000f" % 1 ''') # ok: %% should not count towards placeholder count self.flakes(''' '%% %s %% %s' % (1, 2) ''') # ok: * consumes one positional argument self.flakes(''' '%.f' % (2, 1.1234) '%.f' % (5, 2, 3.1234) ''') def test_ok_percent_format_cannot_determine_element_count(self): self.flakes(''' a = [] '%s %s' % [a] '%s %s' % (a,) ''') self.flakes(''' k = {} '%(k)s' % {*k} ''') class TestAsyncStatements(TestCase): def test_asyncDef(self): self.flakes(''' async def bar(): return 42 ''') def test_asyncDefAwait(self): self.flakes(''' async def read_data(db): await db.fetch('SELECT ...') ''') def test_asyncDefUndefined(self): self.flakes(''' async def bar(): return foo() ''', m.UndefinedName) def test_asyncFor(self): self.flakes(''' async def read_data(db): output = [] async for row in db.cursor(): output.append(row) return output ''') def test_asyncForUnderscoreLoopVar(self): self.flakes(''' async def coro(it): async for _ in it: pass ''') def test_loopControlInAsyncFor(self): self.flakes(''' async def read_data(db): output = [] async for row in db.cursor(): if row[0] == 'skip': continue output.append(row) return output ''') self.flakes(''' async def read_data(db): output = [] async for row in db.cursor(): if row[0] == 'stop': break output.append(row) return output ''') def test_loopControlInAsyncForElse(self): self.flakes(''' async def read_data(db): output = [] async for row in db.cursor(): output.append(row) else: continue return output ''', m.ContinueOutsideLoop) self.flakes(''' async def read_data(db): output = [] async for row in db.cursor(): output.append(row) else: break return output ''', m.BreakOutsideLoop) @skipIf(version_info > (3, 8), "Python <= 3.8 only") def test_continueInAsyncForFinally(self): self.flakes(''' async def read_data(db): output = [] async for row in db.cursor(): try: output.append(row) finally: continue return output ''', m.ContinueInFinally) def test_asyncWith(self): self.flakes(''' async def commit(session, data): async with session.transaction(): await session.update(data) ''') def test_asyncWithItem(self): self.flakes(''' async def commit(session, data): async with session.transaction() as trans: await trans.begin() ... await trans.end() ''') def test_matmul(self): self.flakes(''' def foo(a, b): return a @ b ''') def test_formatstring(self): self.flakes(''' hi = 'hi' mom = 'mom' f'{hi} {mom}' ''') def test_raise_notimplemented(self): self.flakes(''' raise NotImplementedError("This is fine") ''') self.flakes(''' raise NotImplementedError ''') self.flakes(''' raise NotImplemented("This isn't gonna work") ''', m.RaiseNotImplemented) self.flakes(''' raise NotImplemented ''', m.RaiseNotImplemented) class TestIncompatiblePrintOperator(TestCase): """ Tests for warning about invalid use of print function. """ def test_valid_print(self): self.flakes(''' print("Hello") ''') def test_invalid_print_when_imported_from_future(self): exc = self.flakes(''' from __future__ import print_function import sys print >>sys.stderr, "Hello" ''', m.InvalidPrintSyntax).messages[0] self.assertEqual(exc.lineno, 4) self.assertEqual(exc.col, 0) def test_print_function_assignment(self): """ A valid assignment, tested for catching false positives. """ self.flakes(''' from __future__ import print_function log = print log("Hello") ''') def test_print_in_lambda(self): self.flakes(''' from __future__ import print_function a = lambda: print ''') def test_print_returned_in_function(self): self.flakes(''' from __future__ import print_function def a(): return print ''') def test_print_as_condition_test(self): self.flakes(''' from __future__ import print_function if print: pass ''')	50.48 KB	2026-01-20 12:58
📄 test_type_annotations.py """ Tests for behaviour related to type annotations. """ from sys import version_info from pyflakes import messages as m from pyflakes.test.harness import TestCase, skipIf class TestTypeAnnotations(TestCase): def test_typingOverload(self): """Allow intentional redefinitions via @typing.overload""" self.flakes(""" import typing from typing import overload @overload def f(s): # type: (None) -> None pass @overload def f(s): # type: (int) -> int pass def f(s): return s @typing.overload def g(s): # type: (None) -> None pass @typing.overload def g(s): # type: (int) -> int pass def g(s): return s """) def test_typingExtensionsOverload(self): """Allow intentional redefinitions via @typing_extensions.overload""" self.flakes(""" import typing_extensions from typing_extensions import overload @overload def f(s): # type: (None) -> None pass @overload def f(s): # type: (int) -> int pass def f(s): return s @typing_extensions.overload def g(s): # type: (None) -> None pass @typing_extensions.overload def g(s): # type: (int) -> int pass def g(s): return s """) def test_typingOverloadAsync(self): """Allow intentional redefinitions via @typing.overload (async)""" self.flakes(""" from typing import overload @overload async def f(s): # type: (None) -> None pass @overload async def f(s): # type: (int) -> int pass async def f(s): return s """) def test_overload_with_multiple_decorators(self): self.flakes(""" from typing import overload dec = lambda f: f @dec @overload def f(x): # type: (int) -> int pass @dec @overload def f(x): # type: (str) -> str pass @dec def f(x): return x """) def test_overload_in_class(self): self.flakes(""" from typing import overload class C: @overload def f(self, x): # type: (int) -> int pass @overload def f(self, x): # type: (str) -> str pass def f(self, x): return x """) def test_aliased_import(self): """Detect when typing is imported as another name""" self.flakes(""" import typing as t @t.overload def f(s): # type: (None) -> None pass @t.overload def f(s): # type: (int) -> int pass def f(s): return s """) def test_not_a_typing_overload(self): """regression test for @typing.overload detection bug in 2.1.0""" self.flakes(""" def foo(x): return x @foo def bar(): pass def bar(): pass """, m.RedefinedWhileUnused) def test_variable_annotations(self): self.flakes(''' name: str age: int ''') self.flakes(''' name: str = 'Bob' age: int = 18 ''') self.flakes(''' class C: name: str age: int ''') self.flakes(''' class C: name: str = 'Bob' age: int = 18 ''') self.flakes(''' def f(): name: str age: int ''') self.flakes(''' def f(): name: str = 'Bob' age: int = 18 foo: not_a_real_type = None ''', m.UnusedVariable, m.UnusedVariable, m.UnusedVariable, m.UndefinedName) self.flakes(''' def f(): name: str print(name) ''', m.UndefinedName) self.flakes(''' from typing import Any def f(): a: Any ''') self.flakes(''' foo: not_a_real_type ''', m.UndefinedName) self.flakes(''' foo: not_a_real_type = None ''', m.UndefinedName) self.flakes(''' class C: foo: not_a_real_type ''', m.UndefinedName) self.flakes(''' class C: foo: not_a_real_type = None ''', m.UndefinedName) self.flakes(''' def f(): class C: foo: not_a_real_type ''', m.UndefinedName) self.flakes(''' def f(): class C: foo: not_a_real_type = None ''', m.UndefinedName) self.flakes(''' from foo import Bar bar: Bar ''') self.flakes(''' from foo import Bar bar: 'Bar' ''') self.flakes(''' import foo bar: foo.Bar ''') self.flakes(''' import foo bar: 'foo.Bar' ''') self.flakes(''' from foo import Bar def f(bar: Bar): pass ''') self.flakes(''' from foo import Bar def f(bar: 'Bar'): pass ''') self.flakes(''' from foo import Bar def f(bar) -> Bar: return bar ''') self.flakes(''' from foo import Bar def f(bar) -> 'Bar': return bar ''') self.flakes(''' bar: 'Bar' ''', m.UndefinedName) self.flakes(''' bar: 'foo.Bar' ''', m.UndefinedName) self.flakes(''' from foo import Bar bar: str ''', m.UnusedImport) self.flakes(''' from foo import Bar def f(bar: str): pass ''', m.UnusedImport) self.flakes(''' def f(a: A) -> A: pass class A: pass ''', m.UndefinedName, m.UndefinedName) self.flakes(''' def f(a: 'A') -> 'A': return a class A: pass ''') self.flakes(''' a: A class A: pass ''', m.UndefinedName) self.flakes(''' a: 'A' class A: pass ''') self.flakes(''' T: object def f(t: T): pass ''', m.UndefinedName) self.flakes(''' T: object def g(t: 'T'): pass ''') self.flakes(''' a: 'A B' ''', m.ForwardAnnotationSyntaxError) self.flakes(''' a: 'A; B' ''', m.ForwardAnnotationSyntaxError) self.flakes(''' a: '1 + 2' ''') self.flakes(''' a: 'a: "A"' ''', m.ForwardAnnotationSyntaxError) def test_TypeAlias_annotations(self): self.flakes(""" from typing_extensions import TypeAlias from foo import Bar bar: TypeAlias = Bar """) self.flakes(""" from typing_extensions import TypeAlias from foo import Bar bar: TypeAlias = 'Bar' """) self.flakes(""" from typing_extensions import TypeAlias from foo import Bar class A: bar: TypeAlias = Bar """) self.flakes(""" from typing_extensions import TypeAlias from foo import Bar class A: bar: TypeAlias = 'Bar' """) self.flakes(""" from typing_extensions import TypeAlias bar: TypeAlias """) self.flakes(""" from typing_extensions import TypeAlias from foo import Bar bar: TypeAlias """, m.UnusedImport) def test_annotating_an_import(self): self.flakes(''' from a import b, c b: c print(b) ''') def test_unused_annotation(self): # Unused annotations are fine in module and class scope self.flakes(''' x: int class Cls: y: int ''') # TODO: this should print a UnusedVariable message self.flakes(''' def f(): x: int ''') # This should only print one UnusedVariable message self.flakes(''' def f(): x: int x = 3 ''', m.UnusedVariable) def test_annotated_async_def(self): self.flakes(''' class c: pass async def func(c: c) -> None: pass ''') @skipIf(version_info < (3, 7), 'new in Python 3.7') def test_postponed_annotations(self): self.flakes(''' from __future__ import annotations def f(a: A) -> A: pass class A: b: B class B: pass ''') self.flakes(''' from __future__ import annotations def f(a: A) -> A: pass class A: b: Undefined class B: pass ''', m.UndefinedName) self.flakes(''' from __future__ import annotations T: object def f(t: T): pass def g(t: 'T'): pass ''') def test_type_annotation_clobbers_all(self): self.flakes('''\ from typing import TYPE_CHECKING, List from y import z if not TYPE_CHECKING: __all__ = ("z",) else: __all__: List[str] ''') def test_typeCommentsMarkImportsAsUsed(self): self.flakes(""" from mod import A, B, C, D, E, F, G def f( a, # type: A ): # type: (...) -> B for b in a: # type: C with b as c: # type: D d = c.x # type: E return d def g(x): # type: (F) -> G return x.y """) def test_typeCommentsFullSignature(self): self.flakes(""" from mod import A, B, C, D def f(a, b): # type: (A, B[C]) -> D return a + b """) def test_typeCommentsStarArgs(self): self.flakes(""" from mod import A, B, C, D def f(a, b, c): # type: (A, B, *C) -> D return a + b """) def test_typeCommentsFullSignatureWithDocstring(self): self.flakes(''' from mod import A, B, C, D def f(a, b): # type: (A, B[C]) -> D """do the thing!""" return a + b ''') def test_typeCommentsAdditionalComment(self): self.flakes(""" from mod import F x = 1 # type: F # noqa """) def test_typeCommentsNoWhitespaceAnnotation(self): self.flakes(""" from mod import F x = 1 #type:F """) def test_typeCommentsInvalidDoesNotMarkAsUsed(self): self.flakes(""" from mod import F # type: F """, m.UnusedImport) def test_typeCommentsSyntaxError(self): self.flakes(""" def f(x): # type: (F[) -> None pass """, m.CommentAnnotationSyntaxError) def test_typeCommentsSyntaxErrorCorrectLine(self): checker = self.flakes("""\ x = 1 # type: definitely not a PEP 484 comment """, m.CommentAnnotationSyntaxError) self.assertEqual(checker.messages[0].lineno, 2) def test_typeCommentsAssignedToPreviousNode(self): # This test demonstrates an issue in the implementation which # associates the type comment with a node above it, however the type # comment isn't valid according to mypy. If an improved approach # which can detect these "invalid" type comments is implemented, this # test should be removed / improved to assert that new check. self.flakes(""" from mod import F x = 1 # type: F """) def test_typeIgnore(self): self.flakes(""" a = 0 # type: ignore b = 0 # type: ignore[excuse] c = 0 # type: ignore=excuse d = 0 # type: ignore [excuse] e = 0 # type: ignore whatever """) def test_typeIgnoreBogus(self): self.flakes(""" x = 1 # type: ignored """, m.UndefinedName) def test_typeIgnoreBogusUnicode(self): self.flakes(""" x = 2 # type: ignore\xc3 """, m.UndefinedName) def test_return_annotation_is_class_scope_variable(self): self.flakes(""" from typing import TypeVar class Test: Y = TypeVar('Y') def t(self, x: Y) -> Y: return x """) def test_return_annotation_is_function_body_variable(self): self.flakes(""" class Test: def t(self) -> Y: Y = 2 return Y """, m.UndefinedName) @skipIf(version_info < (3, 8), 'new in Python 3.8') def test_positional_only_argument_annotations(self): self.flakes(""" from x import C def f(c: C, /): ... """) def test_partially_quoted_type_annotation(self): self.flakes(""" from queue import Queue from typing import Optional def f() -> Optional['Queue[str]']: return None """) def test_partially_quoted_type_assignment(self): self.flakes(""" from queue import Queue from typing import Optional MaybeQueue = Optional['Queue[str]'] """) def test_nested_partially_quoted_type_assignment(self): self.flakes(""" from queue import Queue from typing import Callable Func = Callable[['Queue[str]'], None] """) def test_quoted_type_cast(self): self.flakes(""" from typing import cast, Optional maybe_int = cast('Optional[int]', 42) """) def test_type_cast_literal_str_to_str(self): # Checks that our handling of quoted type annotations in the first # argument to `cast` doesn't cause issues when (only) the _second_ # argument is a literal str which looks a bit like a type annotation. self.flakes(""" from typing import cast a_string = cast(str, 'Optional[int]') """) def test_quoted_type_cast_renamed_import(self): self.flakes(""" from typing import cast as tsac, Optional as Maybe maybe_int = tsac('Maybe[int]', 42) """) def test_quoted_TypeVar_constraints(self): self.flakes(""" from typing import TypeVar, Optional T = TypeVar('T', 'str', 'Optional[int]', bytes) """) def test_quoted_TypeVar_bound(self): self.flakes(""" from typing import TypeVar, Optional, List T = TypeVar('T', bound='Optional[int]') S = TypeVar('S', int, bound='List[int]') """) def test_literal_type_typing(self): self.flakes(""" from typing import Literal def f(x: Literal['some string']) -> None: return None """) def test_literal_type_typing_extensions(self): self.flakes(""" from typing_extensions import Literal def f(x: Literal['some string']) -> None: return None """) def test_annotated_type_typing_missing_forward_type(self): self.flakes(""" from typing import Annotated def f(x: Annotated['integer']) -> None: return None """, m.UndefinedName) def test_annotated_type_typing_missing_forward_type_multiple_args(self): self.flakes(""" from typing import Annotated def f(x: Annotated['integer', 1]) -> None: return None """, m.UndefinedName) def test_annotated_type_typing_with_string_args(self): self.flakes(""" from typing import Annotated def f(x: Annotated[int, '> 0']) -> None: return None """) def test_annotated_type_typing_with_string_args_in_union(self): self.flakes(""" from typing import Annotated, Union def f(x: Union[Annotated['int', '>0'], 'integer']) -> None: return None """, m.UndefinedName) def test_literal_type_some_other_module(self): """err on the side of false-negatives for types named Literal""" self.flakes(""" from my_module import compat from my_module.compat import Literal def f(x: compat.Literal['some string']) -> None: return None def g(x: Literal['some string']) -> None: return None """) def test_literal_union_type_typing(self): self.flakes(""" from typing import Literal def f(x: Literal['some string', 'foo bar']) -> None: return None """) def test_deferred_twice_annotation(self): self.flakes(""" from queue import Queue from typing import Optional def f() -> "Optional['Queue[str]']": return None """) @skipIf(version_info < (3, 7), 'new in Python 3.7') def test_partial_string_annotations_with_future_annotations(self): self.flakes(""" from __future__ import annotations from queue import Queue from typing import Optional def f() -> Optional['Queue[str]']: return None """) def test_idomiatic_typing_guards(self): # typing.TYPE_CHECKING: python3.5.3+ self.flakes(""" from typing import TYPE_CHECKING if TYPE_CHECKING: from t import T def f(): # type: () -> T pass """) # False: the old, more-compatible approach self.flakes(""" if False: from t import T def f(): # type: () -> T pass """) # some choose to assign a constant and do it that way self.flakes(""" MYPY = False if MYPY: from t import T def f(): # type: () -> T pass """) def test_typing_guard_for_protocol(self): self.flakes(""" from typing import TYPE_CHECKING if TYPE_CHECKING: from typing import Protocol else: Protocol = object class C(Protocol): def f(): # type: () -> int pass """) def test_typednames_correct_forward_ref(self): self.flakes(""" from typing import TypedDict, List, NamedTuple List[TypedDict("x", {})] List[TypedDict("x", x=int)] List[NamedTuple("a", a=int)] List[NamedTuple("a", [("a", int)])] """) self.flakes(""" from typing import TypedDict, List, NamedTuple, TypeVar List[TypedDict("x", {"x": "Y"})] List[TypedDict("x", x="Y")] List[NamedTuple("a", [("a", "Y")])] List[NamedTuple("a", a="Y")] List[TypedDict("x", {"x": List["a"]})] List[TypeVar("A", bound="C")] List[TypeVar("A", List["C"])] """, [m.UndefinedName]7) self.flakes(""" from typing import NamedTuple, TypeVar, cast from t import A, B, C, D, E NamedTuple("A", [("a", A["C"])]) TypeVar("A", bound=A["B"]) TypeVar("A", A["D"]) cast(A["E"], []) """) def test_namedtypes_classes(self): self.flakes(""" from typing import TypedDict, NamedTuple class X(TypedDict): y: TypedDict("z", {"zz":int}) class Y(NamedTuple): y: NamedTuple("v", [("vv", int)]) """) @skipIf(version_info < (3, 11), 'new in Python 3.11') def test_variadic_generics(self): self.flakes(""" from typing import Generic from typing import TypeVarTuple Ts = TypeVarTuple('Ts') class Shape(Generic[Ts]): pass def f(args: Ts) -> None: ... def g(x: Shape[Ts]) -> Shape[Ts]: ... """)	19.83 KB	2026-01-20 12:58
📄 test_undefined_names.py import ast from pyflakes import messages as m, checker from pyflakes.test.harness import TestCase, skip class Test(TestCase): def test_undefined(self): self.flakes('bar', m.UndefinedName) def test_definedInListComp(self): self.flakes('[a for a in range(10) if a]') def test_undefinedInListComp(self): self.flakes(''' [a for a in range(10)] a ''', m.UndefinedName) def test_undefinedExceptionName(self): """Exception names can't be used after the except: block. The exc variable is unused inside the exception handler.""" self.flakes(''' try: raise ValueError('ve') except ValueError as exc: pass exc ''', m.UndefinedName, m.UnusedVariable) def test_namesDeclaredInExceptBlocks(self): """Locals declared in except: blocks can be used after the block. This shows the example in test_undefinedExceptionName is different.""" self.flakes(''' try: raise ValueError('ve') except ValueError as exc: e = exc e ''') @skip('error reporting disabled due to false positives below') def test_undefinedExceptionNameObscuringLocalVariable(self): """Exception names obscure locals, can't be used after. Last line will raise UnboundLocalError on Python 3 after exiting the except: block. Note next two examples for false positives to watch out for.""" self.flakes(''' exc = 'Original value' try: raise ValueError('ve') except ValueError as exc: pass exc ''', m.UndefinedName) def test_undefinedExceptionNameObscuringLocalVariable2(self): """Exception names are unbound after the `except:` block. Last line will raise UnboundLocalError. The exc variable is unused inside the exception handler. """ self.flakes(''' try: raise ValueError('ve') except ValueError as exc: pass print(exc) exc = 'Original value' ''', m.UndefinedName, m.UnusedVariable) def test_undefinedExceptionNameObscuringLocalVariableFalsePositive1(self): """Exception names obscure locals, can't be used after. Unless. Last line will never raise UnboundLocalError because it's only entered if no exception was raised.""" self.flakes(''' exc = 'Original value' try: raise ValueError('ve') except ValueError as exc: print('exception logged') raise exc ''', m.UnusedVariable) def test_delExceptionInExcept(self): """The exception name can be deleted in the except: block.""" self.flakes(''' try: pass except Exception as exc: del exc ''') def test_undefinedExceptionNameObscuringLocalVariableFalsePositive2(self): """Exception names obscure locals, can't be used after. Unless. Last line will never raise UnboundLocalError because `error` is only falsy if the `except:` block has not been entered.""" self.flakes(''' exc = 'Original value' error = None try: raise ValueError('ve') except ValueError as exc: error = 'exception logged' if error: print(error) else: exc ''', m.UnusedVariable) @skip('error reporting disabled due to false positives below') def test_undefinedExceptionNameObscuringGlobalVariable(self): """Exception names obscure globals, can't be used after. Last line will raise UnboundLocalError because the existence of that exception name creates a local scope placeholder for it, obscuring any globals, etc.""" self.flakes(''' exc = 'Original value' def func(): try: pass # nothing is raised except ValueError as exc: pass # block never entered, exc stays unbound exc ''', m.UndefinedLocal) @skip('error reporting disabled due to false positives below') def test_undefinedExceptionNameObscuringGlobalVariable2(self): """Exception names obscure globals, can't be used after. Last line will raise NameError on Python 3 because the name is locally unbound after the `except:` block, even if it's nonlocal. We should issue an error in this case because code only working correctly if an exception isn't raised, is invalid. Unless it's explicitly silenced, see false positives below.""" self.flakes(''' exc = 'Original value' def func(): global exc try: raise ValueError('ve') except ValueError as exc: pass # block never entered, exc stays unbound exc ''', m.UndefinedLocal) def test_undefinedExceptionNameObscuringGlobalVariableFalsePositive1(self): """Exception names obscure globals, can't be used after. Unless. Last line will never raise NameError because it's only entered if no exception was raised.""" self.flakes(''' exc = 'Original value' def func(): global exc try: raise ValueError('ve') except ValueError as exc: print('exception logged') raise exc ''', m.UnusedVariable) def test_undefinedExceptionNameObscuringGlobalVariableFalsePositive2(self): """Exception names obscure globals, can't be used after. Unless. Last line will never raise NameError because `error` is only falsy if the `except:` block has not been entered.""" self.flakes(''' exc = 'Original value' def func(): global exc error = None try: raise ValueError('ve') except ValueError as exc: error = 'exception logged' if error: print(error) else: exc ''', m.UnusedVariable) def test_functionsNeedGlobalScope(self): self.flakes(''' class a: def b(): fu fu = 1 ''') def test_builtins(self): self.flakes('range(10)') def test_builtinWindowsError(self): """ C{WindowsError} is sometimes a builtin name, so no warning is emitted for using it. """ self.flakes('WindowsError') def test_moduleAnnotations(self): """ Use of the C{__annotations__} in module scope should not emit an undefined name warning when version is greater than or equal to 3.6. """ self.flakes('__annotations__') def test_magicGlobalsFile(self): """ Use of the C{__file__} magic global should not emit an undefined name warning. """ self.flakes('__file__') def test_magicGlobalsBuiltins(self): """ Use of the C{__builtins__} magic global should not emit an undefined name warning. """ self.flakes('__builtins__') def test_magicGlobalsName(self): """ Use of the C{__name__} magic global should not emit an undefined name warning. """ self.flakes('__name__') def test_magicGlobalsPath(self): """ Use of the C{__path__} magic global should not emit an undefined name warning, if you refer to it from a file called __init__.py. """ self.flakes('__path__', m.UndefinedName) self.flakes('__path__', filename='package/__init__.py') def test_magicModuleInClassScope(self): """ Use of the C{__module__} magic builtin should not emit an undefined name warning if used in class scope. """ self.flakes('__module__', m.UndefinedName) self.flakes(''' class Foo: __module__ ''') self.flakes(''' class Foo: def bar(self): __module__ ''', m.UndefinedName) def test_magicQualnameInClassScope(self): """ Use of the C{__qualname__} magic builtin should not emit an undefined name warning if used in class scope. """ self.flakes('__qualname__', m.UndefinedName) self.flakes(''' class Foo: __qualname__ ''') self.flakes(''' class Foo: def bar(self): __qualname__ ''', m.UndefinedName) def test_globalImportStar(self): """Can't find undefined names with import .""" self.flakes('from fu import ; bar', m.ImportStarUsed, m.ImportStarUsage) def test_definedByGlobal(self): """ "global" can make an otherwise undefined name in another function defined. """ self.flakes(''' def a(): global fu; fu = 1 def b(): fu ''') self.flakes(''' def c(): bar def b(): global bar; bar = 1 ''') def test_definedByGlobalMultipleNames(self): """ "global" can accept multiple names. """ self.flakes(''' def a(): global fu, bar; fu = 1; bar = 2 def b(): fu; bar ''') def test_globalInGlobalScope(self): """ A global statement in the global scope is ignored. """ self.flakes(''' global x def foo(): print(x) ''', m.UndefinedName) def test_global_reset_name_only(self): """A global statement does not prevent other names being undefined.""" # Only different undefined names are reported. # See following test that fails where the same name is used. self.flakes(''' def f1(): s def f2(): global m ''', m.UndefinedName) @skip("todo") def test_unused_global(self): """An unused global statement does not define the name.""" self.flakes(''' def f1(): m def f2(): global m ''', m.UndefinedName) def test_del(self): """Del deletes bindings.""" self.flakes('a = 1; del a; a', m.UndefinedName) def test_delGlobal(self): """Del a global binding from a function.""" self.flakes(''' a = 1 def f(): global a del a a ''') def test_delUndefined(self): """Del an undefined name.""" self.flakes('del a', m.UndefinedName) def test_delConditional(self): """ Ignores conditional bindings deletion. """ self.flakes(''' context = None test = True if False: del(test) assert(test) ''') def test_delConditionalNested(self): """ Ignored conditional bindings deletion even if they are nested in other blocks. """ self.flakes(''' context = None test = True if False: with context(): del(test) assert(test) ''') def test_delWhile(self): """ Ignore bindings deletion if called inside the body of a while statement. """ self.flakes(''' def test(): foo = 'bar' while False: del foo assert(foo) ''') def test_delWhileTestUsage(self): """ Ignore bindings deletion if called inside the body of a while statement and name is used inside while's test part. """ self.flakes(''' def _worker(): o = True while o is not True: del o o = False ''') def test_delWhileNested(self): """ Ignore bindings deletions if node is part of while's test, even when del is in a nested block. """ self.flakes(''' context = None def _worker(): o = True while o is not True: while True: with context(): del o o = False ''') def test_globalFromNestedScope(self): """Global names are available from nested scopes.""" self.flakes(''' a = 1 def b(): def c(): a ''') def test_laterRedefinedGlobalFromNestedScope(self): """ Test that referencing a local name that shadows a global, before it is defined, generates a warning. """ self.flakes(''' a = 1 def fun(): a a = 2 return a ''', m.UndefinedLocal) def test_laterRedefinedGlobalFromNestedScope2(self): """ Test that referencing a local name in a nested scope that shadows a global declared in an enclosing scope, before it is defined, generates a warning. """ self.flakes(''' a = 1 def fun(): global a def fun2(): a a = 2 return a ''', m.UndefinedLocal) def test_intermediateClassScopeIgnored(self): """ If a name defined in an enclosing scope is shadowed by a local variable and the name is used locally before it is bound, an unbound local warning is emitted, even if there is a class scope between the enclosing scope and the local scope. """ self.flakes(''' def f(): x = 1 class g: def h(self): a = x x = None print(x, a) print(x) ''', m.UndefinedLocal) def test_doubleNestingReportsClosestName(self): """ Test that referencing a local name in a nested scope that shadows a variable declared in two different outer scopes before it is defined in the innermost scope generates an UnboundLocal warning which refers to the nearest shadowed name. """ exc = self.flakes(''' def a(): x = 1 def b(): x = 2 # line 5 def c(): x x = 3 return x return x return x ''', m.UndefinedLocal).messages[0] # _DoctestMixin.flakes adds two lines preceding the code above. expected_line_num = 7 if self.withDoctest else 5 self.assertEqual(exc.message_args, ('x', expected_line_num)) def test_laterRedefinedGlobalFromNestedScope3(self): """ Test that referencing a local name in a nested scope that shadows a global, before it is defined, generates a warning. """ self.flakes(''' def fun(): a = 1 def fun2(): a a = 1 return a return a ''', m.UndefinedLocal) def test_undefinedAugmentedAssignment(self): self.flakes( ''' def f(seq): a = 0 seq[a] += 1 seq[b] /= 2 c[0] = 2 a -= 3 d += 4 e[any] = 5 ''', m.UndefinedName, # b m.UndefinedName, # c m.UndefinedName, m.UnusedVariable, # d m.UndefinedName, # e ) def test_nestedClass(self): """Nested classes can access enclosing scope.""" self.flakes(''' def f(foo): class C: bar = foo def f(self): return foo return C() f(123).f() ''') def test_badNestedClass(self): """Free variables in nested classes must bind at class creation.""" self.flakes(''' def f(): class C: bar = foo foo = 456 return foo f() ''', m.UndefinedName) def test_definedAsStarArgs(self): """Star and double-star arg names are defined.""" self.flakes(''' def f(a, b, *c): print(a, b, c) ''') def test_definedAsStarUnpack(self): """Star names in unpack are defined.""" self.flakes(''' a, b = range(10) print(a, b) ''') self.flakes(''' a, b = range(10) print(a, b) ''') self.flakes(''' a, b, c = range(10) print(a, b, c) ''') def test_usedAsStarUnpack(self): """ Star names in unpack are used if RHS is not a tuple/list literal. """ self.flakes(''' def f(): a, b = range(10) ''') self.flakes(''' def f(): (a, b) = range(10) ''') self.flakes(''' def f(): [a, b, c] = range(10) ''') def test_unusedAsStarUnpack(self): """ Star names in unpack are unused if RHS is a tuple/list literal. """ self.flakes(''' def f(): a, b = any, all, 4, 2, 'un' ''', m.UnusedVariable, m.UnusedVariable) self.flakes(''' def f(): (a, b) = [bool, int, float, complex] ''', m.UnusedVariable, m.UnusedVariable) self.flakes(''' def f(): [a, b, c] = 9, 8, 7, 6, 5, 4 ''', m.UnusedVariable, m.UnusedVariable, m.UnusedVariable) def test_keywordOnlyArgs(self): """Keyword-only arg names are defined.""" self.flakes(''' def f(, a, b=None): print(a, b) ''') self.flakes(''' import default_b def f(, a, b=default_b): print(a, b) ''') def test_keywordOnlyArgsUndefined(self): """Typo in kwonly name.""" self.flakes(''' def f(, a, b=default_c): print(a, b) ''', m.UndefinedName) def test_annotationUndefined(self): """Undefined annotations.""" self.flakes(''' from abc import note1, note2, note3, note4, note5 def func(a: note1, args: note2, b: note3=12, **kw: note4) -> note5: pass ''') self.flakes(''' def func(): d = e = 42 def func(a: {1, d}) -> (lambda c: e): pass ''') def test_metaClassUndefined(self): self.flakes(''' from abc import ABCMeta class A(metaclass=ABCMeta): pass ''') def test_definedInGenExp(self): """ Using the loop variable of a generator expression results in no warnings. """ self.flakes('(a for a in [1, 2, 3] if a)') self.flakes('(b for b in (a for a in [1, 2, 3] if a) if b)') def test_undefinedInGenExpNested(self): """ The loop variables of generator expressions nested together are not defined in the other generator. """ self.flakes('(b for b in (a for a in [1, 2, 3] if b) if b)', m.UndefinedName) self.flakes('(b for b in (a for a in [1, 2, 3] if a) if a)', m.UndefinedName) def test_undefinedWithErrorHandler(self): """ Some compatibility code checks explicitly for NameError. It should not trigger warnings. """ self.flakes(''' try: socket_map except NameError: socket_map = {} ''') self.flakes(''' try: _memoryview.contiguous except (NameError, AttributeError): raise RuntimeError("Python >= 3.3 is required") ''') # If NameError is not explicitly handled, generate a warning self.flakes(''' try: socket_map except: socket_map = {} ''', m.UndefinedName) self.flakes(''' try: socket_map except Exception: socket_map = {} ''', m.UndefinedName) def test_definedInClass(self): """ Defined name for generator expressions and dict/set comprehension. """ self.flakes(''' class A: T = range(10) Z = (x for x in T) L = [x for x in T] B = dict((i, str(i)) for i in T) ''') self.flakes(''' class A: T = range(10) X = {x for x in T} Y = {x:x for x in T} ''') def test_definedInClassNested(self): """Defined name for nested generator expressions in a class.""" self.flakes(''' class A: T = range(10) Z = (x for x in (a for a in T)) ''') def test_undefinedInLoop(self): """ The loop variable is defined after the expression is computed. """ self.flakes(''' for i in range(i): print(i) ''', m.UndefinedName) self.flakes(''' [42 for i in range(i)] ''', m.UndefinedName) self.flakes(''' (42 for i in range(i)) ''', m.UndefinedName) def test_definedFromLambdaInDictionaryComprehension(self): """ Defined name referenced from a lambda function within a dict/set comprehension. """ self.flakes(''' {lambda: id(x) for x in range(10)} ''') def test_definedFromLambdaInGenerator(self): """ Defined name referenced from a lambda function within a generator expression. """ self.flakes(''' any(lambda: id(x) for x in range(10)) ''') def test_undefinedFromLambdaInDictionaryComprehension(self): """ Undefined name referenced from a lambda function within a dict/set comprehension. """ self.flakes(''' {lambda: id(y) for x in range(10)} ''', m.UndefinedName) def test_undefinedFromLambdaInComprehension(self): """ Undefined name referenced from a lambda function within a generator expression. """ self.flakes(''' any(lambda: id(y) for x in range(10)) ''', m.UndefinedName) def test_dunderClass(self): code = ''' class Test(object): def __init__(self): print(__class__.__name__) self.x = 1 t = Test() ''' self.flakes(code) class NameTests(TestCase): """ Tests for some extra cases of name handling. """ def test_impossibleContext(self): """ A Name node with an unrecognized context results in a RuntimeError being raised. """ tree = ast.parse("x = 10") file_tokens = checker.make_tokens("x = 10") # Make it into something unrecognizable. tree.body[0].targets[0].ctx = object() self.assertRaises(RuntimeError, checker.Checker, tree, file_tokens=file_tokens)	23.01 KB	2026-01-20 12:58

Terminal