How to use flake8 - 10 common examples

def _run_flake8(module_paths, config_file=None):
    flake8_opts = ["--statistics"]

    if config_file:
        flake8_opts.append("--append-config={}".format(config_file))

    flake8_opts.extend(module_paths)

    app = application.Application()
    app.run(flake8_opts)
    try:
        app.exit()
    except SystemExit:
        pass

    if app.result_count > 0 or app.catastrophic_failure:
        sys.exit(app.result_count or 1)

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()

args.from_ref = '{}^'.format(args.to_ref)

    # If provided, set the path to the git binary for GitPython
    if args.git_bin is not None:
        os.environ['GIT_PYTHON_GIT_EXECUTABLE'] = os.path.abspath(args.git_bin)
    # The following is done to insure that we import git only after setting
    # the environment variable to specify the path to the git bin received on
    # the command line
    global git
    import git

    # Move to the git directory
    os.chdir(args.git_dir)

    # Prepare the Flake8 checker
    flake8style = flake8.get_style_guide(
        quiet=True,
        # No need to select or ignore anything, it should pick-up the project
        # configuration when run from the project directory
    )
    flake8style.init_report(reporter=Flake8DictReport)

    if args.all:
        checkerhandler_cls = CheckerHandler
    elif args.staged:
        checkerhandler_cls = CheckerHandlerStaged
    else:
        checkerhandler_cls = CheckerHandlerCommits

    checkerhandler_args = vars(args)
    checkerhandler_args.update(git_dir='.')
    checkerhandler = checkerhandler_cls(**checkerhandler_args)

def test_flake8():
    style_guide = get_style_guide(extend_ignore=['D100', 'D104'],
                                  show_source=True)
    style_guide_tests = get_style_guide(
        extend_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_bundle')])
    report_tests = style_guide_tests.check_files(
        [str(Path(__file__).parents[1] / 'tests')])
    sys.stdout = stdout

    total_errors = report.total_errors + report_tests.total_errors
    if total_errors:  # pragma: no cover
        # output summary with per-category counts

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, None, False)
    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_flake8():
    style_guide = legacy.get_style_guide()
    report = style_guide.check_files(['lavalink'])
    statistics = report.get_statistics('E')

    if not statistics:
        print('OK')

def test_flake8():

    # list of all file names to be checked for PEP8
    filenames = list()

    # fill list with all python files found in all subdirectories
    for root, dirs, files in os.walk("gatorgrouper", topdown=False):
        pyFiles = glob.glob(root + "/*.py")
        filenames.extend(pyFiles)

    style_guide = flake8.get_style_guide(ignore=["E265", "E501"])
    report = style_guide.check_files(filenames)
    assert report.get_statistics('E') == [], 'Flake8 found violations'

def test_enable_local_plugin_at_non_installed_path():
    """Can add a paths option in local-plugins config section for finding."""
    app = application.Application()
    app.initialize(['flake8', '--config', LOCAL_PLUGIN_PATH_CONFIG])

    assert app.check_plugins['XE'].plugin.name == 'ExtensionTestPlugin2'

def get_style_guide(argv=None):
    # this is a fork of flake8.api.legacy.get_style_guide
    # to allow passing command line argument
    application = Application()
    if not hasattr(application, 'parse_preliminary_options_and_args'):  # flake8 >= 3.8
        prelim_opts, remaining_args = application.parse_preliminary_options(argv)
        config_finder = config.ConfigFileFinder(
            application.program,
            prelim_opts.append_config,
            config_file=prelim_opts.config,
            ignore_config_files=prelim_opts.isolated,
        )
        application.find_plugins(config_finder)
        application.register_plugin_options()
        application.parse_configuration_and_cli(config_finder, remaining_args)
    else:
        application.parse_preliminary_options_and_args(argv)
        configure_logging(
            application.prelim_opts.verbose, application.prelim_opts.output_file)
        application.make_config_finder()

def get_style_guide(argv=None):
    # this is a fork of flake8.api.legacy.get_style_guide
    # to allow passing command line argument
    application = Application()
    application.parse_preliminary_options_and_args([])
    application.make_config_finder()
    application.find_plugins()
    application.register_plugin_options()
    application.parse_configuration_and_cli(argv)
    application.make_formatter()
    application.make_guide()
    application.make_file_checker_manager()
    return StyleGuide(application)