def test_flake8():
style_guide = get_style_guide(
ignore=['D100', 'D104'],
show_source=True,
)
style_guide_tests = get_style_guide(
ignore=['D100', 'D101', 'D102', 'D103', 'D104', 'D105', 'D107'],
show_source=True,
)
stdout = sys.stdout
sys.stdout = sys.stderr
# implicitly calls report_errors()
report = style_guide.check_files([
str(Path(__file__).parents[1] / 'colcon_cmake'),
])
report_tests = style_guide_tests.check_files([
str(Path(__file__).parents[1] / 'test'),
])
sys.stdout = stdout
total_errors = report.total_errors + report_tests.total_errors
if total_errors: # pragma: no cover
# output summary with per-category counts
print()
report._application.formatter.show_statistics(report._stats)
print('flake8 reported {total_errors} errors'.format_map(locals()),
file=sys.stderr)
assert not report.total_errors, \
'flake8 reported {total_errors} errors'.format_map(locals())
def test_flake8():
style_guide = get_style_guide(
extend_ignore=['D100', 'D104', 'W503'],
show_source=True,
)
style_guide_tests = get_style_guide(
extend_ignore=['D100', 'D101', 'D102', 'D103', 'D104', 'D105', 'D107'],
show_source=True,
)
report = style_guide.check_files([
os.path.join(os.path.dirname(__file__), '..', 'rosdoc2'),
])
report_tests = style_guide_tests.check_files([
os.path.join(os.path.dirname(__file__), '..', 'test'),
])
total_errors = report.total_errors + report_tests.total_errors
if total_errors:
# output summary with per-category counts
print()
if report.total_errors:
report._application.formatter.show_statistics(report._stats)
if report_tests.total_errors:
report_tests._application.formatter.show_statistics(
report_tests._stats)
print('flake8 reported {total_errors} errors'.format_map(locals()),
file=sys.stderr)
assert not total_errors, \
'flake8 reported {total_errors} errors'.format_map(locals())
def get_flake8_errors():
# chrdir so reported paths are relative to it (and not absolute)
with chdir(str(REPO_ROOT)):
output = StringIO()
with redirect_stdout(output):
get_style_guide().check_files(['.'])
return list(filter(None, output.getvalue().split('\n')))
def test_flake8():
style_guide = legacy.get_style_guide()
report = style_guide.check_files(['ksoftapi'])
statistics = report.get_statistics('E')
failed = bool(statistics)
return failed
def test_js101_eq(eq_file_path):
style_guide = flake8.get_style_guide(select=['JS101'], )
p = os.path.abspath(eq_file_path)
r = style_guide.check_files([p])
assert 0 == r.total_errors
def test_js102_multiple_opening(multiple_opening_file_path):
style_guide = flake8.get_style_guide(select=['JS102'], )
p = os.path.abspath(multiple_opening_file_path)
r = style_guide.check_files([p])
assert 1 == r.total_errors
def test_flake8():
test_dir = os.path.dirname(os.path.abspath(inspect.getfile(
inspect.currentframe())))
basedir = os.path.dirname(test_dir)
# Possibility to ignore some files and paths.
ignore_paths = [
os.path.join(basedir, "doc"),
os.path.join(basedir, ".git"),
os.path.join(basedir, "scripts")]
files = []
for dirpath, _, filenames in os.walk(basedir):
ignore = False
for path in ignore_paths:
if dirpath.startswith(path):
ignore = True
break
if ignore:
continue
filenames = [_i for _i in filenames if
os.path.splitext(_i)[-1] == os.path.extsep + "py"]
if not filenames:
continue
for py_file in filenames:
full_path = os.path.join(dirpath, py_file)
files.append(full_path)
style_guide = flake8.get_style_guide(ignore=['E24', 'W503', 'E226'])
report = style_guide.check_files(files)
assert report.get_statistics('E') == [], 'Flake8 found violations'
assert report.total_errors == 0
def test_flake8(self):
python_filepaths = self._get_python_filepaths(FLAKE8_ROOTS)
style_guide = get_style_guide(paths=FLAKE8_OPTIONS)
fake_stdout = io.StringIO()
with patch('sys.stdout', fake_stdout):
report = style_guide.check_files(python_filepaths)
self.assertEqual(report.total_errors, 0, "There are issues!\n" + fake_stdout.getvalue())
def run(self):
from flake8.api.legacy import get_style_guide
flake8_style = get_style_guide(config_file="setup.cfg")
paths = self.distribution_files()
report = flake8_style.check_files(paths)
raise SystemExit(report.total_errors > 0)
async def test_all_options(tmpdir, test_client, loop, template_engine, session,
database, example):
StartProject(
path=str(tmpdir),
name='foobar',
template_engine=template_engine,
session=session,
database=database,
example=example,
)
assert 'app' in {p.basename for p in tmpdir.listdir()}
style_guide = flake8.get_style_guide()
report = style_guide.check_files([str(tmpdir)])
assert report.total_errors == 0
if database != 'none':
return
config = Config(app_path='app/main.py',
root_path=str(tmpdir),
static_path='.')
app_factory = config.import_app_factory()
app = app_factory()
modify_main_app(app, config)
cli = await test_client(app)
r = await cli.get('/')
assert r.status == 200
text = await r.text()
assert '<title>foobar</title>' in text
def flake8(line, cell):
"""flake8 cell magic"""
logger.setLevel(logging.INFO)
with tempfile.NamedTemporaryFile(mode='r+', delete=False) as f:
# save to file
f.write(cell)
# make sure it's written
f.flush()
f.close()
flake = flake8_module.get_style_guide(
extend_ignore=['W292', 'W391', 'F401', 'F821'])
# flake_result = flake.check_files([f.name])
# # split lines
# stdout = sys.stdout.getvalue().splitlines()
# for line in stdout:
# logger.info(line)
# # sys.stdout = old_stdout
with io.StringIO() as buf, redirect_stdout(buf):
_ = flake.check_files([f.name])
for line in buf.getvalue().splitlines():
# on windows drive path also contains :
temp_file, line, col, error = line.split(':')[-4:]
# add + 1 for line as first line is %%flake8, inc pre py3.6 string
logger.info('{}:{}:{}'.format(int(line) + 1, col, error))
# try:
# os.remove(f.name)
# except OSError as e: # if failed, report it back to the user
# logger.error("Error: %s - %s." % (e.filename, e.strerror))
return
def test_pep8(self):
# verify all files are nicely styled
python_filepaths = get_python_filepaths()
style_guide = get_style_guide()
fake_stdout = io.StringIO()
with patch('sys.stdout', fake_stdout):
report = style_guide.check_files(python_filepaths)
# if flake8 didnt' report anything, we're done
if report.total_errors == 0:
return
# grab on which files we have issues
flake8_issues = fake_stdout.getvalue().split('\n')
broken_filepaths = {
item.split(':')[0]
for item in flake8_issues if item
}
# give hints to the developer on how files' style could be improved
options = autopep8.parse_args([''])
options.aggressive = 1
options.diff = True
options.max_line_length = 99
issues = []
for filepath in broken_filepaths:
diff = autopep8.fix_file(filepath, options=options)
if diff:
issues.append(diff)
report = ["Please fix files as suggested by autopep8:"] + issues
report += ["\n-- Original flake8 reports:"] + flake8_issues
self.fail("\n".join(report))
async def test_db_creation(tmpdir, test_client, loop):
StartProject(
path=str(tmpdir),
name='foobar postgres test',
template_engine=TemplateChoice.JINJA,
session=SessionChoices.NONE,
database=DatabaseChoice.PG_SA,
example=ExampleChoice.MESSAGE_BOARD,
)
assert 'app' in {p.basename for p in tmpdir.listdir()}
style_guide = flake8.get_style_guide()
report = style_guide.check_files([str(tmpdir)])
assert report.total_errors == 0
db_password = os.getenv('APP_DB_PASSWORD', '')
env = {
'APP_DB_PASSWORD': db_password,
'PATH': os.getenv('PATH', ''),
}
p = subprocess.run(['make', 'reset-database'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
cwd=str(tmpdir), env=env, universal_newlines=True)
assert p.returncode == 0, p.stdout
assert 'creating database "foobar"...'
assert 'creating tables from model definition...'
os.environ['APP_DB_PASSWORD'] = db_password
config = Config(app_path='app/main.py', root_path=str(tmpdir))
app = config.app_factory(loop=loop)
modify_main_app(app, config)
cli = await test_client(app)
r = await cli.get('/')
assert r.status == 200
text = await r.text()
assert '<title>foobar postgres test</title>' in text
def check_syntax(self):
"""
From flake8
"""
packages = settings.PACKAGES_TO_TEST
# Prepare
config_options = getattr(yak_settings, 'FLAKE8_CONFIG', {})
flake8_style = get_style_guide(**config_options)
# Save to file for later printing instead of printing now
old_stdout = sys.stdout
sys.stdout = out = open('syntax_output', 'w+')
# Run the checkers
report = flake8_style.check_files(paths=packages)
sys.stdout = old_stdout
# Print the final report
if report.total_errors:
out.close()
with open("syntax_output") as f:
self.fail("{0} Syntax warnings!\n\n{1}".format(
report.total_errors, f.read()))
def flake8_on_files(files, commit):
""" Runs flake8 on the files to report style guide violations.
"""
style = get_style_guide(config_file=None, quiet=False)
# We need to redirect stdout while generating the JSON to avoid spilling
# messages to the user.
old_stdout = sys.stdout
sys.stdout = open("/dev/null", "w")
review = {}
for file in filter_files(files, (".py", )):
report = style.check_files((file, ))
if report.total_errors:
if not "comments" in review:
review["comments"] = defaultdict(list)
for line_number, offset, code, text, doc in report._deferred_print:
if not line_part_of_commit(file, line_number, commit): continue
review["comments"][file].append({
"path": file,
"line": line_number,
"message": "[{0}] {1}".format(code, text)
})
if "comments" in review and len(review["comments"]):
review["message"] = "[FLAKE8] Some issues found."
else:
review["message"] = "[FLAKE8] No issues found. OK"
sys.stdout = old_stdout
return json.dumps(review)
def test_flake8():
test_dir = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
basedir = os.path.dirname(test_dir)
# Possibility to ignore some files and paths.
ignore_paths = [
os.path.join(basedir, "doc"),
os.path.join(basedir, ".git"),
os.path.join(basedir, "scripts")
]
files = []
for dirpath, _, filenames in os.walk(basedir):
ignore = False
for path in ignore_paths:
if dirpath.startswith(path):
ignore = True
break
if ignore:
continue
filenames = [
_i for _i in filenames
if os.path.splitext(_i)[-1] == os.path.extsep + "py"
]
if not filenames:
continue
for py_file in filenames:
full_path = os.path.join(dirpath, py_file)
files.append(full_path)
style_guide = flake8.get_style_guide()
report = style_guide.check_files(files)
assert report.total_errors == 0
def __check_for_undefined_names(self):
"""
Checks the plugin module for undefined names. This catches
missing imports, references to nonexistent variables, etc.
..note::
We are using the legacy flake8 api, because there is currently
no public, stable api for flake8 >= 3.0.0
For more info, see
https://flake8.pycqa.org/en/latest/user/python-api.html
"""
warnings = defaultdict(list)
src_dir = self.__plugin_config_content['srcDir']
exclude_dir = os.path.sep.join([src_dir, CODEGEN_PACKAGE])
style_guide = flake8.get_style_guide(select=["F821"],
exclude=[exclude_dir],
quiet=1)
style_guide.check_files(paths=[src_dir])
file_checkers = style_guide._application.file_checker_manager.checkers
for checker in file_checkers:
for result in checker.results:
# From the api code, result is a tuple defined as: error =
# (error_code, line_number, column, text, physical_line)
if result[0] == 'F821':
msg = "{} on line {} in {}".format(result[3], result[1],
checker.filename)
warnings['exception'].append(exceptions.UserError(msg))
if warnings and len(warnings) > 0:
raise exceptions.ValidationFailedError(warnings)
def test_flake8():
test_dir = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
package_dir = os.path.dirname(test_dir)
# Possibility to ignore some files and paths.
ignore_paths = [
os.path.join(package_dir, "doc"),
os.path.join(package_dir, ".git")
]
files = []
for dirpath, _, filenames in os.walk(package_dir):
ignore = False
for path in ignore_paths:
if dirpath.startswith(path):
ignore = True
break
if ignore:
continue
filenames = [
_i for _i in filenames
if os.path.splitext(_i)[-1] == os.path.extsep + "py"
]
if not filenames:
continue
for py_file in filenames:
full_path = os.path.join(dirpath, py_file)
files.append(full_path)
# Get the style checker with the default style.
style_guide = flake8.get_style_guide(ignore=['E24', 'W503', 'E226'])
report = style_guide.check_files(files)
assert report.get_statistics('E') == [], 'Flake8 found violations'
assert report.total_errors == 0
def test_js102_dict(dict_file_path):
style_guide = flake8.get_style_guide(select=['JS102'], )
p = os.path.abspath(dict_file_path)
r = style_guide.check_files([p])
assert 1 == r.total_errors
def test_flake8_conformance(self):
with CaptureStdout() as stdout:
flake8_style = flake8.get_style_guide(
exclude=['*/env/*', '*/node_modules/*', '*/migrations/*'])
report = flake8_style.check_files([settings.BASE_DIR])
if report.total_errors > 0:
self.fail('Got some flake8 errors:\n{0}'.format(stdout), )
def check_flake8():
if not HAS_FLAKE8:
raise Exception('flake8 is required to check code formatting')
# pyflakes autodetection of PY2 does not work with the future library.
# Therefore, overwrite the pyflakes autodetection manually
if PY2:
import pyflakes.checker # @UnusedImport
pyflakes.checker.PY2 = True
test_dir = os.path.abspath(inspect.getfile(inspect.currentframe()))
obspy_dir = os.path.dirname(os.path.dirname(os.path.dirname(test_dir)))
untracked_files = get_untracked_files_from_git() or []
files = []
for dirpath, _, filenames in os.walk(obspy_dir):
filenames = [
_i for _i in filenames
if os.path.splitext(_i)[-1] == os.path.extsep + "py"
]
if not filenames:
continue
for py_file in filenames:
py_file = os.path.join(dirpath, py_file)
# ignore untracked files
if os.path.abspath(py_file) in untracked_files:
continue
# exclude *.py files in obspy/lib
try:
tmp_dir, _ = os.path.split(py_file)
_, tmp_dir = os.path.split(tmp_dir)
if tmp_dir == "lib":
continue
except:
pass
# Check files that do not match any exclusion pattern
for exclude_pattern in FLAKE8_EXCLUDE_FILES:
if fnmatch.fnmatch(py_file, exclude_pattern):
break
else:
files.append(py_file)
if flake8_version >= LooseVersion('3.0.0'):
from flake8.api.legacy import get_style_guide
else:
from flake8.engine import get_style_guide
flake8_kwargs = {'parse_argv': False}
if flake8_version < LooseVersion('2.5.5'):
import flake8.main
flake8_kwargs['config_file'] = flake8.main.DEFAULT_CONFIG
flake8_style = get_style_guide(**flake8_kwargs)
flake8_style.options.ignore = tuple(
set(flake8_style.options.ignore).union(set(FLAKE8_IGNORE_CODES)))
with CatchOutput() as out:
files = [native_str(f) for f in files]
report = flake8_style.check_files(files)
return report, out.stdout
def test_js102_list_comprehension(list_file_path):
style_guide = flake8.get_style_guide(select=['JS102'], )
p = os.path.abspath(list_file_path)
r = style_guide.check_files([p])
assert 0 == r.total_errors
def flake8_on_files(files, commit):
""" Runs flake8 on the files to report style guide violations.
"""
style = get_style_guide(config_file=None, quiet=False)
# We need to redirect stdout while generating the JSON to avoid spilling
# messages to the user.
old_stdout = sys.stdout
sys.stdout = open("/dev/null", "w")
review = {}
for file in filter_files(files, (".py", )):
report = style.check_files((file, ))
if report.total_errors:
if not "comments" in review:
review["comments"] = defaultdict(list)
for line_number, offset, code, text, doc in report._deferred_print:
if not line_part_of_commit(file, line_number, commit): continue
review["comments"][file].append({
"path":
file,
"line":
line_number,
"message":
"[{0}] {1}".format(code, text)
})
if "comments" in review and len(review["comments"]):
review["message"] = "[FLAKE8] Some issues found."
else:
review["message"] = "[FLAKE8] No issues found. OK"
sys.stdout = old_stdout
return json.dumps(review)
def test_get_style_guide():
"""Verify the methods called on our internal Application."""
prelim_opts = argparse.Namespace(
append_config=[],
config=None,
isolated=False,
output_file=None,
verbose=0,
)
mockedapp = mock.Mock()
mockedapp.parse_preliminary_options.return_value = (prelim_opts, [])
mockedapp.program = "flake8"
with mock.patch(
"flake8.api.legacy.config.ConfigFileFinder"
) as mock_config_finder: # noqa: E501
config_finder = ConfigFileFinder(mockedapp.program)
mock_config_finder.return_value = config_finder
with mock.patch("flake8.main.application.Application") as application:
application.return_value = mockedapp
style_guide = api.get_style_guide()
application.assert_called_once_with()
mockedapp.parse_preliminary_options.assert_called_once_with([])
mockedapp.find_plugins.assert_called_once_with(config_finder)
mockedapp.register_plugin_options.assert_called_once_with()
mockedapp.parse_configuration_and_cli.assert_called_once_with(
config_finder, []
)
mockedapp.make_formatter.assert_called_once_with()
mockedapp.make_guide.assert_called_once_with()
mockedapp.make_file_checker_manager.assert_called_once_with()
assert isinstance(style_guide, api.StyleGuide)
def test_get_style_guide():
"""Verify the methods called on our internal Application."""
prelim_opts = argparse.Namespace(
append_config=[],
config=None,
isolated=False,
output_file=None,
verbose=0,
)
mockedapp = mock.Mock()
mockedapp.parse_preliminary_options_and_args.return_value = (
prelim_opts,
[],
)
with mock.patch('flake8.main.application.Application') as application:
application.return_value = mockedapp
style_guide = api.get_style_guide()
application.assert_called_once_with()
mockedapp.parse_preliminary_options_and_args.assert_called_once_with([])
mockedapp.make_config_finder.assert_called_once_with([], [])
mockedapp.find_plugins.assert_called_once_with(None, False)
mockedapp.register_plugin_options.assert_called_once_with()
mockedapp.parse_configuration_and_cli.assert_called_once_with([])
mockedapp.make_formatter.assert_called_once_with()
mockedapp.make_guide.assert_called_once_with()
mockedapp.make_file_checker_manager.assert_called_once_with()
assert isinstance(style_guide, api.StyleGuide)
def flake8_scan_file(commit_sha, owner, repo, parent_sha=None):
"""Runs flake8 scan on all changed files and returns array of warnings"""
if parent_sha is None:
parent_sha = get_commit_parent(commit_sha, owner, repo)
diff_url = GIT_COMPARE_URL.format(base=parent_sha,
head=commit_sha,
owner=owner,
repo=repo,
host=host_api)
diff_info = get(diff_url, auth=auth).json()
diff_content = get(diff_url,
auth=auth,
headers={
"Accept": "application/vnd.github.v3.diff"
}).content.decode('utf8')
patch_set = PatchSet(diff_content)
comments_per_file = {}
for file in diff_info['files']:
content = get(file['contents_url'], auth=auth).json()
file_content = get(content['download_url']).content
with open("flake8_tmp_file.py", 'wb') as test_file:
test_file.write(file_content)
style_guide = flake8.get_style_guide(ignore=['E24', 'W503'])
style_guide.input_file('./flake8_tmp_file.py', )
results = style_guide._application.file_checker_manager.checkers[
0].results
comments_per_line = {}
for code, line_n, offset, text, src in results:
if changed_in_diff(get_file_by_name(patch_set, file['filename']),
line_n):
comments = comments_per_line.get(line_n, [])
comments.append((file['filename'], line_n, offset, code, text))
comments_per_line[line_n] = comments
comments_per_file[file['filename']] = comments_per_line
return comments_per_file
def test_js102_pound(pound_file_path):
"""Pound signs in strings shouldn't be considered the start of comments."""
style_guide = flake8.get_style_guide(select=['JS102'], )
p = os.path.abspath(pound_file_path)
r = style_guide.check_files([p])
assert 0 == r.total_errors
def test_check(self):
"""Performing checks by flake8
"""
style_guide = flake8.get_style_guide(max_line_length=120,
ignore=['W504', 'N802'])
report = style_guide.check_files(self.list_of_files)
self.assertEqual(report.total_errors, 0)
def test_js102_function_calls_ignored(function_calls_file_path):
"""Function calls should not trigger JS102."""
style_guide = flake8.get_style_guide(select=['JS102'], )
p = os.path.abspath(function_calls_file_path)
r = style_guide.check_files([p])
assert 0 == r.total_errors
def use_flake8(self, files, ignore):
style_guide = flake8.get_style_guide(ignore=ignore)
output = io.StringIO()
with redirect_stdout(output):
style_guide.check_files(files)
report = output.getvalue().split('\n')
final_information = ''
return self._parse_flake8(report), final_information
def py_lint(file_list, parseable=False):
from flake8.api.legacy import get_style_guide
file_list = get_python_files(file_list)
flake8_style = get_style_guide(parse_argv=True)
report = flake8_style.check_files(file_list)
return report.total_errors != 0
def test_flake8_pytest(mocker):
python_filepaths = get_python_filepaths(FLAKE8_ROOTS)
style_guide = get_style_guide(paths=FLAKE8_OPTIONS)
fake_stdout = io.StringIO()
mocker.patch('sys.stdout', fake_stdout)
report = style_guide.check_files(python_filepaths)
assert report.total_errors == 0, "There are issues!\n" + fake_stdout.getvalue(
)
def run_flake8():
formatted_message("Running flake8...", "yellow")
from flake8.api import legacy as flake8
style_guide = flake8.get_style_guide(ignore=['H101','H301','H306','H401',
'E402','H403','H404','H405']
)
report = style_guide.check_files(["."])
assert report.total_errors == 0, '\033[31;1mERROR\033[31;1;1m Flake8 found errors\033[0m'
def check_flake8():
if not HAS_FLAKE8:
raise Exception('flake8 is required to check code formatting')
# pyflakes autodetection of PY2 does not work with the future library.
# Therefore, overwrite the pyflakes autodetection manually
if PY2:
import pyflakes.checker # @UnusedImport
pyflakes.checker.PY2 = True
test_dir = os.path.abspath(inspect.getfile(inspect.currentframe()))
obspy_dir = os.path.dirname(os.path.dirname(os.path.dirname(test_dir)))
untracked_files = get_untracked_files_from_git() or []
files = []
for dirpath, _, filenames in os.walk(obspy_dir):
filenames = [_i for _i in filenames if
os.path.splitext(_i)[-1] == os.path.extsep + "py"]
if not filenames:
continue
for py_file in filenames:
py_file = os.path.join(dirpath, py_file)
# ignore untracked files
if os.path.abspath(py_file) in untracked_files:
continue
# exclude *.py files in obspy/lib
try:
tmp_dir, _ = os.path.split(py_file)
_, tmp_dir = os.path.split(tmp_dir)
if tmp_dir == "lib":
continue
except:
pass
# Check files that do not match any exclusion pattern
for exclude_pattern in FLAKE8_EXCLUDE_FILES:
if fnmatch.fnmatch(py_file, exclude_pattern):
break
else:
files.append(py_file)
if flake8_version >= LooseVersion('3.0.0'):
from flake8.api.legacy import get_style_guide
else:
from flake8.engine import get_style_guide
flake8_kwargs = {'parse_argv': False}
if flake8_version < LooseVersion('2.5.5'):
import flake8.main
flake8_kwargs['config_file'] = flake8.main.DEFAULT_CONFIG
flake8_style = get_style_guide(**flake8_kwargs)
flake8_style.options.ignore = tuple(set(
flake8_style.options.ignore).union(set(FLAKE8_IGNORE_CODES)))
with CatchOutput() as out:
files = [native_str(f) for f in files]
report = flake8_style.check_files(files)
return report, out.stdout
def test_legacy_api(tmpdir):
"""A basic end-to-end test for the legacy api reporting errors."""
with tmpdir.as_cwd():
t_py = tmpdir.join('t.py')
t_py.write('import os # unused import\n')
style_guide = legacy.get_style_guide()
report = style_guide.check_files([t_py.strpath])
assert report.total_errors == 1
def assert_conforms_to_style(python_files):
checker = flake8.get_style_guide(max_complexity=MAX_COMPLEXITY)
checker.options.jobs = 1
checker.options.verbose = True
report = checker.check_files(python_files)
warnings = report.get_statistics("W")
errors = report.get_statistics("E")
assert not (warnings or errors), "\n" + "\n".join(["Warnings:", "\n".join(warnings), "Errors:", "\n".join(errors)])
def test_cython_files():
style_guide = flake8.get_style_guide(
filename=['*.pyx', '*.px'],
exclude=['doc', '.eggs', '*.egg', 'build', 'setup.py'],
select=['E', 'W', 'F'],
ignore=['E225'],
max_line_length=88
)
report = style_guide.check_files()
assert report.get_statistics('E') == []
assert report.get_statistics('W') == []
assert report.get_statistics('F') == []
def test_regular_files():
style_guide = flake8.get_style_guide(
filename=['*.py'],
exclude=['doc', '.eggs', '*.egg', 'build', 'benchmark.py',
'run_all_examples.py'],
select=['E', 'W', 'F'],
max_line_length=88
)
report = style_guide.check_files()
assert report.get_statistics('E') == []
assert report.get_statistics('W') == []
assert report.get_statistics('F') == []
def test_get_style_guide():
"""Verify the methods called on our internal Application."""
mockedapp = mock.Mock()
with mock.patch('flake8.main.application.Application') as Application:
Application.return_value = mockedapp
style_guide = api.get_style_guide()
Application.assert_called_once_with()
mockedapp.find_plugins.assert_called_once_with()
mockedapp.register_plugin_options.assert_called_once_with()
mockedapp.parse_configuration_and_cli.assert_called_once_with([])
mockedapp.make_formatter.assert_called_once_with()
mockedapp.make_notifier.assert_called_once_with()
mockedapp.make_guide.assert_called_once_with()
mockedapp.make_file_checker_manager.assert_called_once_with()
assert isinstance(style_guide, api.StyleGuide)
def check_flake8(filename):
style_guide = flake8.get_style_guide()
report = style_guide.check_files([filename])
score = 0
if report.get_statistics('E') == []:
score += 4
if report.get_statistics('W') == []:
score += 3
else:
logger.info(report.get_statistics('W'))
if report.get_statistics('F') == []:
score += 3
else:
logger.info(report.get_statistics('F'))
else:
logger.info(report.get_statistics('E'))
return score
def test_get_style_guide():
"""Verify the methods called on our internal Application."""
mockedapp = mock.Mock()
mockedapp.prelim_opts.verbose = 0
mockedapp.prelim_opts.output_file = None
with mock.patch('flake8.main.application.Application') as application:
application.return_value = mockedapp
style_guide = api.get_style_guide()
application.assert_called_once_with()
mockedapp.parse_preliminary_options_and_args.assert_called_once_with([])
mockedapp.make_config_finder.assert_called_once_with()
mockedapp.find_plugins.assert_called_once_with()
mockedapp.register_plugin_options.assert_called_once_with()
mockedapp.parse_configuration_and_cli.assert_called_once_with([])
mockedapp.make_formatter.assert_called_once_with()
mockedapp.make_guide.assert_called_once_with()
mockedapp.make_file_checker_manager.assert_called_once_with()
assert isinstance(style_guide, api.StyleGuide)
def test_flake8():
if get_style_guide is None:
# skip test on Python 2.6 and older
return
style_guide = get_style_guide(
exclude=['conf.py'],
ignore=[
'C402', # ignore presence of unnecessary generators
'C405', # ignore presence of unnecessary literals
'C407', # ignore presence of unnecessary comprehensions
'C408', # ignore presence of unnecessary tuple/list/dict
'D', # ignore documentation related warnings
'F401', # ignore presence of unused imports
'F841', # ignore presence of unused variables
'I', # ignore import order related warnings
'N802', # ignore presence of upper case in function names
],
max_line_length=200,
show_source=True,
)
stdout = sys.stdout
sys.stdout = sys.stderr
# implicitly calls report_errors()
report = style_guide.check_files([
os.path.dirname(os.path.dirname(__file__)),
])
sys.stdout = stdout
if report.total_errors:
# output summary with per-category counts
print()
report._application.formatter.show_statistics(report._stats)
print(
'flake8 reported {report.total_errors} errors'
.format_map(locals()), file=sys.stderr)
assert not report.total_errors, \
'flake8 reported {report.total_errors} errors'.format_map(locals())
def run(self, apps_locations, **options):
output = open(os.path.join(options['output_dir'], 'flake8.report'), 'w')
pep8_options = {}
config_file = self.get_config_path(options)
if config_file is not None:
pep8_options['config_file'] = config_file
set_option(pep8_options, 'exclude', options['pep8-exclude'], config_file,
default=pep8.DEFAULT_EXCLUDE + ",south_migrations", split=',')
set_option(pep8_options, 'select', options['pep8-select'], config_file, split=',')
set_option(pep8_options, 'ignore', options['pep8-ignore'], config_file, split=',')
set_option(pep8_options, 'max_line_length', options['pep8-max-line-length'], config_file,
default=pep8.MAX_LINE_LENGTH)
set_option(pep8_options, 'max_complexity', options['flake8-max-complexity'], config_file,
default=-1)
old_stdout, flake8_output = sys.stdout, StringIO()
sys.stdout = flake8_output
pep8style = get_style_guide(
parse_argv=False,
jobs='1',
**pep8_options)
try:
for location in apps_locations:
pep8style.input_file(os.path.relpath(location))
finally:
sys.stdout = old_stdout
flake8_output.seek(0)
output.write(flake8_output.read())
output.close()
def test_flake8():
if get_style_guide is None:
# skip test on Python 2.6 and older
return
style_guide = get_style_guide(
exclude=[],
ignore=[
'E731', # ignore assign lambda warning
'E226', # ignore whitespace around arithmetic operators
'E305', # ignore whitespace before/after functions rule
'D', # ignore documentation related warnings
'I', # ignore import order related warnings
'N802', # ignore presence of upper case in function names
],
max_line_length=100,
max_complexity=10,
show_source=True,
)
stdout = sys.stdout
sys.stdout = sys.stderr
# implicitly calls report_errors()
report = style_guide.check_files([
os.path.dirname(os.path.dirname(__file__)),
])
sys.stdout = stdout
if report.total_errors:
# output summary with per-category counts
print()
report._application.formatter.show_statistics(report._stats)
print(
'flake8 reported {report.total_errors} errors'
.format_map(locals()), file=sys.stderr)
assert not report.total_errors, \
'flake8 reported {report.total_errors} errors'.format(**locals())
def check_style(notebook_code):
"""
The notebook PEP 8 test ignore:
W292: blank line at end of file (always present when using nbconvert)
E226: missing whitespace around arithmetic operator (not enforced by PEP 8)
E402: module level import not at top of file (for notebooks it is clearer
to import at the top of the cell of its first use.)
"""
lines = notebook_code.split('\n')
notebook_code = '\n'.join(
[line for line in lines if not line.startswith('get_ipython')]
)
fid, fname = mkstemp(suffix='.py', prefix='temp_script_')
with open(fname, 'w') as f:
f.write(notebook_code.strip())
style_guide = flake8.get_style_guide(
ignore=['W292', 'E226', 'E402'],
max_line_length=100
)
report = style_guide.input_file(fname)
os.close(fid)
return report
def test_flake8():
# Configure flake8 using the .flake8 file in the root of this repository.
style_guide = get_style_guide()
style_guide.options.exclude += ['*/doc/_build']
stdout = sys.stdout
sys.stdout = sys.stderr
# implicitly calls report_errors()
report = style_guide.check_files([
os.path.dirname(os.path.dirname(__file__)),
])
sys.stdout = stdout
if report.total_errors:
# output summary with per-category counts
print()
report._application.formatter.show_statistics(report._stats)
print(
'flake8 reported %d errors' % report.total_errors,
file=sys.stderr)
assert not report.total_errors, \
'flake8 reported %d errors' % report.total_errors
def check_syntax(self):
"""
From flake8
"""
packages = settings.PACKAGES_TO_TEST
# Prepare
config_options = getattr(yak_settings, 'FLAKE8_CONFIG', {})
flake8_style = get_style_guide(**config_options)
# Save to file for later printing instead of printing now
old_stdout = sys.stdout
sys.stdout = out = open('syntax_output', 'w+')
# Run the checkers
report = flake8_style.check_files(paths=packages)
sys.stdout = old_stdout
# Print the final report
if report.total_errors:
out.close()
with open("syntax_output") as f:
self.fail("{0} Syntax warnings!\n\n{1}".format(report.total_errors, f.read()))
def flake8_examine(file_location):
style_guide = f8.get_style_guide()
result = style_guide.check_files([file_location])
num_of_errors = result.total_errors
return num_of_errors
def handle(self, *args, **options): os.chdir(os.path.join(os.path.join(BASE_DIR, '..'))) style = flake8.get_style_guide(config_file='.flake8') report = style.check_files(['_1327']) if report.total_errors > 0: sys.exit(1)
style_guide = flake8.get_style_guide(
ignore=(
'E129', # visually indented line with same indent (in gui.py)
'E501', # line too long
'E126', # continuation line over-indented for hanging indent
'E128', # continuation line under-indented for visual indent
# 'E221', # multiple spaces before operator
# 'E222', # multiple spaces after operator
'E722', # do not use bare except
'F403', # 'import *' used; unable to detect undefined names
'F405', # ... may be undefined, or defined from star imports: ...
),
report=None,
exclude=[
# old files:
# 'f-engrave-140.py',
# 'py2exe_setup.py',
# new files:
# '__init__.py'
# 'gui.py',
# 'job.py',
# 'settings.py',
# 'tooltip.py',
# 'bitmap_settings.py',
# 'general_settings.py',
# 'vcarve_settings.py',
# geometry:
# 'boundingbox.py'
# 'coords.py',
# 'engrave.py'
# 'font.py',
# 'linearcfitter.py',
# 'pathsorter.py',
# readers:
# 'bspline.py',
# 'dxf_class.py',
# 'elements.py',
# 'nurbs.py',
# 'cxf.py',
# 'font.py',
# 'image.py'
# writers:
# 'dxf.py',
# 'gcode.py',
# 'svg.py',
# util:
# 'externals.py'
# 'icon.py'
]
)
def test_flake8():
# Configure flake8 using the .flake8 file in the root of this repository.
style = get_style_guide()
results = style.check_files()
assert results.total_errors == 0, 'Found code style errors / warnings'
