def scan(self, code, filename=""):
code = utils.sanitize_code(code)
self.code = code.splitlines()
self.noqa_lines = noqa.parse_noqa(self.code)
self.filename = filename
try:
node = ast.parse(code, filename=self.filename)
except SyntaxError as err:
text = ' at "{}"'.format(err.text.strip()) if err.text else ""
print(
"{}:{:d}: {}{}".format(
utils.format_path(filename), err.lineno, err.msg, text
),
file=sys.stderr,
)
self.found_dead_code_or_error = True
except (TypeError, ValueError) as err:
# Python < 3.5 raises TypeError and Python >= 3.5 raises
# ValueError if source contains null bytes.
print(
'{}: invalid source code "{}"'.format(
utils.format_path(filename), err
),
file=sys.stderr,
)
self.found_dead_code_or_error = True
else:
self.visit(node)
def get_whitelist_string(self):
filename = utils.format_path(self.filename)
if self.typ == 'unreachable_code':
return ('# {} ({}:{})'.format(
self.message, filename, self.first_lineno))
else:
prefix = '_.' if self.typ in ['attribute', 'property'] else ''
return "{}{} # unused {} ({}:{:d})".format(
prefix, self.name, self.typ, filename, self.first_lineno)
def get_report(self, add_size=False):
if add_size:
line_format = 'line' if self.size == 1 else 'lines'
size_report = ', {0:d} {1}'.format(self.size, line_format)
else:
size_report = ''
return "{0}:{1:d}: {2} ({3}% confidence{4})".format(
utils.format_path(self.filename), self.first_lineno,
self.message, self.confidence, size_report)
def get_report(self, add_size=False):
if add_size:
line_format = 'line' if self.size == 1 else 'lines'
size_report = ', {0:d} {1}'.format(self.size, line_format)
else:
size_report = ''
return "{0}:{1:d}: {2} ({3}% confidence{4})".format(
utils.format_path(self.filename), self.first_lineno,
self.message, self.confidence, size_report)
def get_whitelist_string(self):
filename = utils.format_path(self.filename)
if self.typ == "unreachable_code":
return "# {} ({}:{})".format(self.message, filename,
self.first_lineno)
else:
prefix = "_." if self.typ in ["attribute", "property"] else ""
return "{}{} # unused {} ({}:{:d})".format(
prefix, self.name, self.typ, filename, self.first_lineno)
def make_whitelist(self, min_confidence=0, sort_by_size=False):
for item in self.get_unused_code(min_confidence=min_confidence,
sort_by_size=sort_by_size):
if item.typ != 'unreachable_code':
prefix = '_.' if item.typ in ['attribute', 'property'] else ''
print("{}{} # unused {} ({}:{:d})".format(
prefix, item.name, item.typ,
utils.format_path(item.filename), item.first_lineno))
self.found_dead_code_or_error = True
return self.found_dead_code_or_error
def scan(self, code, filename=''):
code = ENCODING_REGEX.sub("", code, count=1)
self.code = code.splitlines()
self.filename = filename
try:
node = ast.parse(code, filename=self.filename)
except SyntaxError as err:
text = ' at "{0}"'.format(err.text.strip()) if err.text else ''
print('{0}:{1:d}: {2}{3}'.format(
utils.format_path(filename), err.lineno, err.msg, text),
file=sys.stderr)
self.found_dead_code_or_error = True
except (TypeError, ValueError) as err:
# Python < 3.5 raises TypeError and Python >= 3.5 raises
# ValueError if source contains null bytes.
print('{0}: invalid source code "{1}"'.format(
utils.format_path(filename), err), file=sys.stderr)
self.found_dead_code_or_error = True
else:
self.visit(node)
def scan(self, code, filename=''):
code = ENCODING_REGEX.sub("", code, count=1)
self.code = code.splitlines()
self.filename = filename
try:
node = ast.parse(code, filename=self.filename)
except SyntaxError as err:
text = ' at "{0}"'.format(err.text.strip()) if err.text else ''
print('{0}:{1:d}: {2}{3}'.format(
utils.format_path(filename), err.lineno, err.msg, text),
file=sys.stderr)
self.found_dead_code_or_error = True
except (TypeError, ValueError) as err:
# Python < 3.5 raises TypeError and Python >= 3.5 raises
# ValueError if source contains null bytes.
print('{0}: invalid source code "{1}"'.format(
utils.format_path(filename), err), file=sys.stderr)
self.found_dead_code_or_error = True
else:
self.visit(node)
def report(self):
"""
Print ordered list of Item objects to stdout.
"""
for item in self.get_unused_code():
line_format = 'line' if item.size == 1 else 'lines'
size_report = (' (%d %s)' % (item.size, line_format)
if self.sort_by_size else '')
print("%s:%d: Unused %s '%s'%s" % (utils.format_path(
item.filename), item.lineno, item.typ, item, size_report))
self.found_dead_code_or_error = True
return self.found_dead_code_or_error
def get_report(self, add_size=False):
if add_size:
line_format = "line" if self.size == 1 else "lines"
size_report = ", {:d} {}".format(self.size, line_format)
else:
size_report = ""
return "{}:{:d}: {} ({}% confidence{})".format(
utils.format_path(self.filename),
self.first_lineno,
self.message,
self.confidence,
size_report,
)
def scan(self, code, filename=''):
code = ENCODING_REGEX.sub("", code, count=1)
self.code = code.splitlines()
self.filename = filename
try:
node = ast.parse(code, filename=self.filename)
except SyntaxError as err:
print('%s:%d: %s at "%s"' %
(utils.format_path(filename), err.lineno, err.msg,
err.text.strip()),
file=sys.stderr)
self.found_dead_code_or_error = True
else:
self.visit(node)
def scan(self, code, filename=''):
code = utils.sanitize_code(code)
self.code = code.splitlines()
self.filename = filename
try:
node = ast.parse(code, filename=self.filename)
except SyntaxError as err:
pass
except (TypeError, ValueError) as err:
# Python < 3.5 raises TypeError and Python >= 3.5 raises
# ValueError if source contains null bytes.
print('{0}: invalid source code "{1}"'.format(
utils.format_path(filename), err),
file=sys.stderr)
self.found_dead_code_or_error = True
else:
self.visit(node)
def test_relative_outside(self, tmp_cwd):
filepath = pathlib.Path(os.pardir) / "testfile.py"
formatted = utils.format_path(filepath)
assert formatted == filepath
assert not formatted.is_absolute()
def test_absolute_outside(self, tmp_cwd):
filepath = (tmp_cwd / os.pardir / "testfile.py").resolve()
formatted = utils.format_path(filepath)
assert formatted == filepath
assert formatted.is_absolute()
def test_absolute_inside(self, tmp_cwd):
filepath = tmp_cwd / "testfile.py"
formatted = utils.format_path(filepath)
assert formatted == pathlib.Path("testfile.py")
assert not formatted.is_absolute()
self.file_path = file_path
self.first_lineno = first_lineno
self.last_lineno = last_lineno
self.reason = reason
def run(self):
pass
def __repr__(self):
return str(self.__dict__)
if __name__ == '__main__':
options, args = _parse_args()
vulture = Vulture(verbose=options.verbose)
vulture.scavenge(args, exclude=options.exclude)
code_items = vulture.get_unused_code(min_confidence=90,
sort_by_size=options.sort_by_size)
DELETION_JOBS = []
for item in code_items:
DELETION_JOBS.append(
DeletionJob(file_path=utils.format_path(item.filename),
first_lineno=item.first_lineno,
last_lineno=item.last_lineno,
reason=item.message +
' ({}% confidence)'.format(item.confidence)))
print(DELETION_JOBS)
def test_relative_inside(self):
filepath = pathlib.Path("testfile.py")
formatted = utils.format_path(filepath)
assert formatted == filepath
assert not formatted.is_absolute()
