def checkFlakes(codeString, filename, reporter):
"""Check the Python source given by codeString} for flakes."""
# First, compile into an AST and handle syntax errors.
try:
tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
except SyntaxError:
value = sys.exc_info()[1]
msg = value.args[0]
(lineno, offset, text) = value.lineno, value.offset, value.text
# If there's an encoding problem with the file, the text is None.
if text is None:
# Avoid using msg, since for the only known case, it contains a
# bogus message that claims the encoding the file declared was
# unknown.
reporter.unexpectedError(filename, 'problem decoding source')
else:
reporter.syntaxError(filename, msg, lineno, offset, text)
return
except Exception:
reporter.unexpectedError(filename, 'problem decoding source')
return
# Okay, it's syntactically valid. Now check it.
w = checker.Checker(tree, filename)
w.messages.sort(key=lambda m: m.lineno)
for warning in w.messages:
reporter.flake(warning)
def python_engine_pyflakes_check(filename):
f = open(filename, 'r')
code = ''.join(f.readlines())
# first, compile into an AST and handle syntax errors.
try:
import _ast
tree = compile(code, "", "exec", _ast.PyCF_ONLY_AST)
except SyntaxError:
value = sys.exc_info()[1]
msg = value.args[0]
(lineno, offset, text) = value.lineno, value.offset, value.text
line = text.splitlines()[-1]
if offset is not None:
offset = offset - (len(text) - len(line))
return ['%s:%d: %s' % ("", lineno, msg)]
return 1
else:
# okay, it's syntactically valid. Now check it.
import pyflakes.checker as checker
w = checker.Checker(tree, "")
w.messages.sort(key=lambda m: m.lineno)
return [warning.__str__() for warning in w.messages]
def pyflakes_check(self, code, filename, ignore=None):
"""Check the code with pyflakes to find errors
"""
class FakeLoc:
lineno = 0
try:
tree = compile(str(code), filename, 'exec', _ast.PyCF_ONLY_AST)
except (SyntaxError, IndentationError) as value:
return self._handle_syntactic_error(code, filename, value)
except ValueError as error:
return [PythonError(filename, FakeLoc(), error.args[0])]
else:
# the file is syntactically valid, check it now
if ignore is not None:
_magic_globals = pyflakes._MAGIC_GLOBALS
pyflakes._MAGIC_GLOBALS += ignore
w = pyflakes.Checker(tree, filename)
if ignore is not None:
pyflakes._MAGIC_GLOBALS = _magic_globals
return w.messages
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:
%s
expected outputs:
%r
but got:
%s"""
% (input, expectedOutputs, "\n".join([str(o) for o in w.messages])),
)
return w
def pyflakes(filename):
codeString = file(filename, 'U').read() + '\n'
errors = []
try:
tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
except SyntaxError as e:
errors.append(dict(
lnum=e.lineno or 0,
col=e.offset or 0,
text=getattr(e, 'msg', None) or str(e),
type='E'
))
else:
w = checker.Checker(tree, filename)
w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
for w in w.messages:
errors.append(dict(
lnum=w.lineno,
col=0,
text=u'{0} {1}'.format(
flake_class_mapping.get(w.__class__, ''),
w.message % w.message_args),
type='E'
))
return errors
def checkCode(codeString):
filename = "code.py"
warning = []
try:
tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
except SyntaxError:
value = sys.exc_info()[1]
msg = value.args[0]
(lineno, offset, text) = value.lineno, value.offset, value.text
if text is None:
error = "unexpectedError: Problema de decodificación de la fuente"
else:
error = "Code.py: " + str(lineno) + ": " + msg + " -> " + text
return True, False, error.capitalize()
except Exception:
#reporter.unexpectedError(filename, 'problem decoding source')
error = "unexpectedError: Problema de decodificación de la fuente"
return False, error
# Okay, it's syntactically valid. Now check it.
w = checker.Checker(tree, filename)
w.messages.sort(key=lambda m: m.lineno)
warns = False
for war in w.messages:
warns = True
warning.append(str(war).capitalize())
return False, warns, warning
def check(codeString, filename, outfile=None):
try:
tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
except (SyntaxError, IndentationError):
value = sys.exc_info()[1]
try:
(lineno, offset, line) = value[1][1:]
except IndexError:
print >> sys.stderr, 'could not compile %r' % (filename, )
return 1
if line.endswith("\n"):
line = line[:-1]
print >> sys.stderr, '%s:%d: could not compile' % (filename, lineno)
print >> sys.stderr, line
print >> sys.stderr, " " * (offset - 2), "^"
return 1
else:
w = checker.Checker(tree, filename)
w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
for warning in w.messages:
if outfile:
outfile.write(str(warning) + '\n')
else:
print warning
return len(w.messages)
def check(codeString, filename, reporter=None):
"""
Check the Python source given by C{codeString} for flakes.
@param codeString: The Python source to check.
@type codeString: C{str}
@param filename: The name of the file the source came from, used to report
errors.
@type filename: C{str}
@param reporter: A L{Reporter} instance, where errors and warnings will be
reported.
@return: The number of warnings emitted.
@rtype: C{int}
"""
if reporter is None:
reporter = modReporter._makeDefaultReporter()
# First, compile into an AST and handle syntax errors.
try:
tree = ast.parse(codeString, filename=filename)
except SyntaxError:
value = sys.exc_info()[1]
msg = value.args[0]
(lineno, offset, text) = value.lineno, value.offset, value.text
if checker.PYPY:
if text is None:
lines = codeString.splitlines()
if len(lines) >= lineno:
text = lines[lineno - 1]
if sys.version_info >= (3, ) and isinstance(text, bytes):
try:
text = text.decode('ascii')
except UnicodeDecodeError:
text = None
offset -= 1
# If there's an encoding problem with the file, the text is None.
if text is None:
# Avoid using msg, since for the only known case, it contains a
# bogus message that claims the encoding the file declared was
# unknown.
reporter.unexpectedError(filename, 'problem decoding source')
else:
reporter.syntaxError(filename, msg, lineno, offset, text)
return 1
except Exception:
reporter.unexpectedError(filename, 'problem decoding source')
return 1
# Okay, it's syntactically valid. Now check it.
file_tokens = checker.make_tokens(codeString)
w = checker.Checker(tree, file_tokens=file_tokens, filename=filename)
w.messages.sort(key=lambda m: m.lineno)
for warning in w.messages:
reporter.flake(warning)
return len(w.messages)
def check(buffer):
filename = buffer.name
contents = buffer[:]
# shebang usually found at the top of the file, followed by source code encoding marker.
# assume everything else that follows is encoded in the encoding.
for n, line in enumerate(contents):
if n >= 2:
break
elif re.match(r'#.*coding[:=]\s*([-\w.]+)', line):
contents = [''] * (n + 1) + contents[n + 1:]
break
contents = '\n'.join(contents) + '\n'
vimenc = vim.eval('&encoding')
if vimenc:
contents = contents.decode(vimenc)
builtins = set(['__file__'])
try:
builtins.update(set(eval(vim.eval('string(g:pyflakes_builtins)'))))
except Exception:
pass
try:
# TODO: use warnings filters instead of ignoring stderr
old_stderr, sys.stderr = sys.stderr, blackhole()
try:
tree = ast.parse(contents, filename or '<unknown>')
finally:
sys.stderr = old_stderr
except:
try:
value = sys.exc_info()[1]
lineno, offset, line = value[1][1:]
except IndexError:
lineno, offset, line = 1, 0, ''
if line and line.endswith("\n"):
line = line[:-1]
return [SyntaxError(filename, lineno, offset, str(value))]
else:
# pyflakes looks to _MAGIC_GLOBALS in checker.py to see which
# UndefinedNames to ignore
old_globals = getattr(checker, ' _MAGIC_GLOBALS', [])
checker._MAGIC_GLOBALS = set(old_globals) | builtins
filename = '(none)' if filename is None else filename
w = checker.Checker(tree, filename)
checker._MAGIC_GLOBALS = old_globals
w.messages.sort(key=attrgetter('lineno'))
return w.messages
def _checkPySource(self, file_path):
with open(file_path) as file_obj:
tree = ast.parse(file_obj.read(), file_path)
warnings = checker.Checker(tree, file_path)
warnings.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
# Log individual errors so we see them all instead of just the first
for msg in warnings.messages:
log.err(self.failureException("pyflakes: %s" % (msg, )))
return len(warnings.messages)
def _validate_pyflakes(fd, options={}):
if is_python3(fd):
# TODO: Pyflakes supports Python 3, but we would need to run it in Python3
return True
from pyflakes import checker
tree = ast.parse(fd.read(), fd.name)
w = checker.Checker(tree, fd.name)
w.messages.sort(key=lambda x: x.lineno)
for message in w.messages:
error = message.message % message.message_args
_detail(error, line=message.lineno)
return len(w.messages) == 0
def get_flakes(source, filename):
try:
tree = ast.parse(source, filename, "exec")
except SyntaxError:
value = sys.exc_info()[1]
msg = value.args[0]
yield Problem('error', value.lineno, value.offset, msg)
else:
results = checker.Checker(tree, filename)
for m in results.messages:
yield Problem('warn', m.lineno, m.col,
m.message % m.message_args)
def check(self, document):
filename = document.get_short_name_for_display()
start, end = document.get_bounds()
text = document.get_text(start, end, True)
try:
with BlackHole():
tree = ast.parse(text, filename)
except SyntaxError as e:
return [PySyntaxError(filename, e.lineno, e.offset, e.text)]
else:
w = checker.Checker(tree, filename)
w.messages.sort(key=attrgetter('lineno'))
return w.messages
def lint(tree):
# Wrap the whole module in a function
# so that pyflakes thinks global variables are local variables
# and reports when they are unused
function_tree = ast.parse("def f(): 0")
function_tree.body[0].body = tree.body
ch = checker.Checker(function_tree, builtins=["assert_equal"])
ch.messages.sort(key=lambda m: m.lineno)
for message in ch.messages:
if type(message) in MESSAGES:
message_format = MESSAGES[type(message)]
yield message_format.format(*message.message_args)
def run_pyflakes(request_data):
"""
Worker that run a frosted (the fork of pyflakes) code analysis on the
current editor text.
"""
global prev_results
from pyflakes import checker
import _ast
WARNING = 1
ERROR = 2
ret_val = []
code = request_data['code']
path = request_data['path']
encoding = request_data['encoding']
if not encoding:
encoding = 'utf-8'
if not path:
path = os.path.join(tempfile.gettempdir(), 'temp.py')
if not code:
return []
else:
# First, compile into an AST and handle syntax errors.
try:
tree = compile(code.encode(encoding), path, "exec",
_ast.PyCF_ONLY_AST)
except SyntaxError as value:
msg = '[pyFlakes] %s' % value.args[0]
(lineno, offset, text) = value.lineno - 1, value.offset, value.text
# If there's an encoding problem with the file, the text is None
if text is None:
# Avoid using msg, since for the only known case, it
# contains a bogus message that claims the encoding the
# file declared was unknown.s
_logger().warning("[SyntaxError] %s: problem decoding source",
path)
else:
ret_val.append((msg, ERROR, lineno))
else:
# Okay, it's syntactically valid. Now check it.
w = checker.Checker(tree, os.path.split(path)[1])
w.messages.sort(key=lambda m: m.lineno)
for message in w.messages:
msg = "[pyFlakes] %s" % str(message).split(':')[-1].strip()
line = message.lineno - 1
status = WARNING \
if message.__class__ not in PYFLAKES_ERROR_MESSAGES \
else ERROR
ret_val.append((msg, status, line))
prev_results = ret_val
return ret_val
def flakes(self, input, *expectedOutputs, **kw):
w = checker.Checker(compiler.parse(textwrap.dedent(input)), **kw)
outputs = [type(o) for o in w.messages]
expectedOutputs = list(expectedOutputs)
outputs.sort()
expectedOutputs.sort()
self.assert_(outputs == expectedOutputs, '''\
for input:
%s
expected outputs:
%s
but got:
%s''' % (input, repr(expectedOutputs), '\n'.join([str(o) for o in w.messages])))
return w
def flakes(self, input, *expectedOutputs, **kw):
tree = compile(textwrap.dedent(input), "<test>", "exec", PyCF_ONLY_AST)
w = checker.Checker(tree, **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:
%s
expected outputs:
%r
but got:
%s''' % (input, expectedOutputs, '\n'.join([str(o) for o in w.messages])))
return w
def validate(code: str, pb: str) -> bool:
try:
tree = ast.parse(code)
results = checker.Checker(tree)
for error in results.messages:
if isinstance(error, UNDEFINED_ERRORS):
for arg in error.message_args:
if arg not in UNDEFINED_ERRORS_TO_IGNORE[pb]:
return False
elif not isinstance(error, ERROR_TYPES_TO_IGNORE):
return False
return True
except SyntaxError:
return False
def pyflakes(filename):
from pyflakes import checker
import _ast
codeString = file(filename, 'U').read() + '\n'
errors = []
tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
w = checker.Checker(tree, filename)
w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
for w in w.messages:
errors.append(
dict(lnum=w.lineno,
col=w.col,
text=w.message % w.message_args,
type='E'))
return errors
def _check_pyflakes(self, path):
if not install_flg['pyflakes']:
return [{'line': 0, 'msg': 'no install pyflakes'}]
arr = []
with open(path, 'r') as f:
for line in f:
arr.append(line)
res = []
tree = ast.parse(''.join(arr), path)
w = checker.Checker(tree, path)
for m in w.messages:
res.append({'line': m.lineno, 'msg': m.message % m.message_args})
return res
def check(codeString, filename, reporter=None):
"""
Check the Python source given by C{codeString} for flakes.
@param codeString: The Python source to check.
@type codeString: C{str}
@param filename: The name of the file the source came from, used to report
errors.
@type filename: C{str}
@param reporter: A L{Reporter} instance, where errors and warnings will be
reported.
@return: The number of warnings emitted.
@rtype: C{int}
"""
if reporter is None:
reporter = modReporter._makeDefaultReporter()
# First, compile into an AST and handle syntax errors.
try:
tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
except SyntaxError:
value = sys.exc_info()[1]
msg = value.args[0]
(lineno, offset, text) = value.lineno, value.offset, value.text
# If there's an encoding problem with the file, the text is None.
if text is None:
# Avoid using msg, since for the only known case, it contains a
# bogus message that claims the encoding the file declared was
# unknown.
reporter.unexpectedError(filename, 'problem decoding source')
else:
reporter.syntaxError(filename, msg, lineno, offset, text)
return 1
except Exception:
reporter.unexpectedError(filename, 'problem decoding source')
return 1
else:
# Okay, it's syntactically valid. Now check it.
w = checker.Checker(tree, filename)
w.messages.sort(key=lambda m: m.lineno)
for warning in w.messages:
reporter.flake(warning)
return len(w.messages)
def check(self, code, filename, ignore=None):
"""Check the code with pyflakes to find errors
"""
class FakeLoc:
lineno = 0
try:
code = code.encode('utf8') + b'\n'
tree = compile(code, filename or '', 'exec', _ast.PyCF_ONLY_AST)
except (SyntaxError, IndentationError):
return self._handle_syntactic_error(code, filename)
except ValueError as error:
return [PyFlakesError(filename, FakeLoc(), error.args[0])]
else:
# the file is syntactically valid, check it now
w = pyflakes.Checker(tree, filename, ignore)
return w.messages
def flakes(self, input, *expectedOutputs, **kw):
ast = compile(textwrap.dedent(input), "<test>", "exec",
_ast.PyCF_ONLY_AST)
w = checker.Checker(ast, **kw)
outputs = [type(o) for o in w.messages]
expectedOutputs = list(expectedOutputs)
outputs.sort()
expectedOutputs.sort()
self.assert_(
outputs == expectedOutputs, '''\
for input:
%s
expected outputs:
%s
but got:
%s''' % (input, repr(expectedOutputs), '\n'.join([str(o)
for o in w.messages])))
return w
def run_check(self, context: RunContext): # noqa
"""Check code with pyflakes."""
params = context.get_params("pyflakes")
builtins = params.get("builtins", "")
if builtins:
builtins = builtins.split(",")
check = checker.Checker(context.ast,
context.filename,
builtins=builtins)
for msg in check.messages:
context.push(
lnum=msg.lineno,
col=msg.col + 1,
text=msg.message % msg.message_args,
number=CODES.get(msg.message, ""),
source="pyflakes",
)
def run(path, code=None, params=None, **meta):
"""Check code with pyflakes.
:return list: List of errors.
"""
import _ast
builtins = params.get("builtins", "")
if builtins:
builtins = builtins.split(",")
tree = compile(code, path, "exec", _ast.PyCF_ONLY_AST)
w = checker.Checker(tree, path, builtins=builtins)
w.messages = sorted(w.messages, key=lambda m: m.lineno)
return [
{'lnum': m.lineno, 'text': m.message % m.message_args}
for m in sorted(w.messages, key=lambda m: m.lineno)
]
def pyflakes_check(self, code, filename, ignore=None):
try:
tree = compile(code, filename, "exec", _ast.PyCF_ONLY_AST)
except (SyntaxError, IndentationError) as value:
msg = value.args[0]
(lineno, offset, text) = value.lineno, value.offset, value.text
# If there's an encoding problem with the file, the text is None.
if text is None:
# Avoid using msg, since for the only known case, it contains a
# bogus message that claims the encoding the file declared was
# unknown.
if msg.startswith('duplicate argument'):
arg = msg.split('duplicate argument ', 1)[1].split(' ', 1)[0].strip('\'"')
error = pyflakes.messages.DuplicateArgument(filename, lineno, arg)
else:
error = PythonError(filename, lineno, msg)
else:
line = text.splitlines()[-1]
if offset is not None:
offset = offset - (len(text) - len(line))
if offset is not None:
error = OffsetError(filename, lineno, msg, offset)
else:
error = PythonError(filename, lineno, msg)
return [error]
except ValueError as e:
return [PythonError(filename, 0, e.args[0])]
else:
# Okay, it's syntactically valid. Now check it.
if ignore is not None:
old_magic_globals = pyflakes._MAGIC_GLOBALS
pyflakes._MAGIC_GLOBALS += ignore
w = pyflakes.Checker(tree, filename)
if ignore is not None:
pyflakes._MAGIC_GLOBALS = old_magic_globals
return w.messages
def run(path, code=None, builtins="", **meta):
""" Pyflake code checking.
:return list: List of errors.
"""
import _ast
import os
os.environ.setdefault('PYFLAKES_BUILTINS', builtins)
errors = []
tree = compile(code, path, "exec", _ast.PyCF_ONLY_AST)
w = checker.Checker(tree, path)
w.messages = sorted(w.messages, key=lambda m: m.lineno)
for w in w.messages:
errors.append(
dict(
lnum=w.lineno,
text=w.message % w.message_args,
))
return errors
def to_output(self):
"""
Produce json output
:return: json result report
"""
results = []
cli = {'cli': results}
warning_dict = {}
try:
tree = ast.parse(self.codeString, filename=self.filename)
file_tokens = checker.make_tokens(self.codeString)
w = checker.Checker(tree,
file_tokens=file_tokens,
filename=self.filename)
w.messages.sort(key=lambda m: m.lineno)
for warning in w.messages:
warning_dict['message'] = str(warning).split(' ', 1)[1]
warning = str(warning).split(' ', 1)[0]
loc = str(warning).split(':')
warning_dict['file'] = loc[0] if loc[0] else None
warning_dict['line'] = loc[1] if loc[1] else None
warning_dict['column'] = loc[2] if loc[2] else None
results.append(warning_dict.copy())
except SyntaxError:
value = sys.exc_info()[1]
msg = value.args[0]
warning_dict['message'] = msg
warning_dict['file'] = self.filename
warning_dict['line'] = value.lineno if value.lineno else None
warning_dict['column'] = value.offset if value.offset else None
results.append(warning_dict.copy())
flakes_json = {'results': cli}
flakes_json = json.dumps(flakes_json,
sort_keys=True,
indent=2,
separators=(',', ': '))
return flakes_json + '\n'
def _check(self, codeString, filename, warnings):
try:
tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
except (SyntaxError, IndentationError) as value:
msg = value.args[0]
(lineno, offset, text) = value.lineno, value.offset, value.text
# If there's an encoding problem with the file, the text is None.
if text is None:
# Avoid using msg, since for the only known case, it contains a
# bogus message that claims the encoding the file declared was
# unknown.
print("{}: problem decoding source".format(filename),
file=sys.stderr)
else:
line = text.splitlines()[-1]
if offset is not None:
offset = offset - (len(text) - len(line))
print("%s:%d: %s" % (filename, lineno, msg), file=sys.stderr)
print(line, file=sys.stderr)
if offset is not None:
print(" " * offset, "^", file=sys.stderr)
return 1
except UnicodeError as msg:
print("encoding error at %r: %s" % (filename, msg),
file=sys.stderr)
return 1
else:
# Okay, it's syntactically valid.
# Now parse it into an ast and check it.
w = checker.Checker(tree, filename)
warnings.extend(w.messages)
return len(warnings)
def run(self, code):
"""Make the analysis
This function is inspired from the check function of the pyflakes start
script.
"""
print("run called in pychecker")
self._code = code
# Open a buffer for the output
output = StringIO()
# Start the check
try:
tree = compiler.parse(self._code)
except (SyntaxError, IndentationError):
value = sys.exc_info()[1]
try:
(lineno, offset, line) = value[1][1:]
except IndexError:
print >> output, _('Could not compile the code.')
else:
if line.endswith("\n"):
line = line[:-1]
print >> output, _('line %d: could not compile') % lineno
print >> output, line
print >> output, " " * (offset - 2), "^"
self._nb_errors = None
else:
w = checker.Checker(tree, 'line')
w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
for warning in w.messages:
print >> output, warning
self._nb_errors = len(w.messages)
# Get the output and remove the irrelevant file path
self._report = output.getvalue()
# Close the buffer
output.close()
