def register_checks(): import pycodestyle from sentry.lint.absolute_import_check import AbsoluteImportCheck from sentry.lint.mock_check import MockCheck pycodestyle.register_check(MockCheck, codes=[MockCheck.code]) pycodestyle.register_check(AbsoluteImportCheck, codes=[AbsoluteImportCheck.code])
def _run_check(self, code, checker, filename=None): pycodestyle.register_check(checker) lines = textwrap.dedent(code).strip().splitlines(True) checker = pycodestyle.Checker(filename=filename, lines=lines) checker.check_all() checker.report._deferred_print.sort() return checker.report._deferred_print
def patch_pep8(): if autopep8_c_i in p8._checks['logical_line']: del p8._checks['logical_line'][autopep8_c_i] p8.register_check(p8.continued_indentation) try: yield finally: del p8._checks['logical_line'][p8.continued_indentation] p8.register_check(autopep8_c_i)
def test_register_ast_check(self): pycodestyle.register_check(DummyChecker, ['Z701']) self.assertTrue(DummyChecker in pycodestyle._checks['tree']) codes, args = pycodestyle._checks['tree'][DummyChecker] self.assertTrue('Z701' in codes) self.assertTrue(args is None) options = pycodestyle.StyleGuide().options self.assertTrue(any(cls == DummyChecker for name, cls, args in options.ast_checks))
def run_check(self, code): pycodestyle.register_check(self.get_checker()) lines = textwrap.dedent(code).strip().splitlines(True) # Load all keystone hacking checks, they are of the form Kddd, # where ddd can from range from 000-999 guide = pycodestyle.StyleGuide(select='K') checker = pycodestyle.Checker(lines=lines, options=guide.options) checker.check_all() checker.report._deferred_print.sort() return checker.report._deferred_print
def test_styleguide_unmatched_triple_quotes(self): pycodestyle.register_check(DummyChecker, ['Z701']) lines = [ 'def foo():\n', ' """test docstring""\'\n', ] pep8style = pycodestyle.StyleGuide() pep8style.input_file('stdin', lines=lines) stdout = sys.stdout.getvalue() expected = 'stdin:2:5: E901 TokenError: EOF in multi-line string' self.assertTrue(expected in stdout)
def test_check_unicode(self): # Do not crash if lines are Unicode (Python 2.x) pycodestyle.register_check(DummyChecker, ['Z701']) source = '#\n' if hasattr(source, 'decode'): source = source.decode('ascii') pep8style = pycodestyle.StyleGuide() count_errors = pep8style.input_file('stdin', lines=[source]) self.assertFalse(sys.stdout) self.assertFalse(sys.stderr) self.assertEqual(count_errors, 0)
def _run_check(self, code, checker, filename=None): pycodestyle.register_check(checker) lines = textwrap.dedent(code).strip().splitlines(True) checker = pycodestyle.Checker(filename=filename, lines=lines) # NOTE(sdague): the standard reporter has printing to stdout # as a normal part of check_all, which bleeds through to the # test output stream in an unhelpful way. This blocks that printing. with mock.patch('pycodestyle.StandardReport.get_file_results'): checker.check_all() checker.report._deferred_print.sort() return checker.report._deferred_print
def test_register_physical_check(self): def check_dummy(physical_line, line_number): if False: yield pycodestyle.register_check(check_dummy, ['Z001']) self.assertTrue(check_dummy in pycodestyle._checks['physical_line']) codes, args = pycodestyle._checks['physical_line'][check_dummy] self.assertTrue('Z001' in codes) self.assertEqual(args, ['physical_line', 'line_number']) options = pycodestyle.StyleGuide().options self.assertTrue(any(func == check_dummy for name, func, args in options.physical_checks))
def test_register_invalid_check(self): class InvalidChecker(DummyChecker): def __init__(self, filename): pass def check_dummy(logical, tokens): if False: yield pycodestyle.register_check(InvalidChecker, ['Z741']) pycodestyle.register_check(check_dummy, ['Z441']) for checkers in pycodestyle._checks.values(): self.assertTrue(DummyChecker not in checkers) self.assertTrue(check_dummy not in checkers) self.assertRaises(TypeError, pycodestyle.register_check)
def add_options(cls, parser): # We're looking for local checks, so we need to include the local # dir in the search path sys.path.append('.') local_check = CONF.get_multiple('local-check', default=[]) for check_path in set(local_check): if check_path.strip(): checker = pbr.util.resolve_name(check_path) pycodestyle.register_check(checker) local_check_fact = CONF.get('local-check-factory') if local_check_fact: factory = pbr.util.resolve_name(local_check_fact) factory(pycodestyle.register_check) sys.path.pop()
def test_check_nullbytes(self): pycodestyle.register_check(DummyChecker, ['Z701']) pep8style = pycodestyle.StyleGuide() count_errors = pep8style.input_file('stdin', lines=['\x00\n']) stdout = sys.stdout.getvalue() if 'SyntaxError' in stdout: # PyPy 2.2 returns a SyntaxError expected = "stdin:1:2: E901 SyntaxError" elif 'ValueError' in stdout: # Python 3.5. expected = "stdin:1:1: E901 ValueError" else: expected = "stdin:1:1: E901 TypeError" self.assertTrue(stdout.startswith(expected), msg='Output %r does not start with %r' % (stdout, expected)) self.assertFalse(sys.stderr) self.assertEqual(count_errors, 1)
def check_easyconfigs_style(easyconfigs, verbose=False): """ Check the given list of easyconfigs for style :param: easyconfigs list of file paths to easyconfigs :param: verbose print our statistics and be verbose about the errors and warning :return: the number of warnings and errors """ # importing autopep8 changes some pep8 functions. # We reload it to be sure to get the real pep8 functions. if 'pycodestyle' in sys.modules: reload(pycodestyle) else: reload(pep8) # register the extra checks before using pep8: # any function in this module starting with `_eb_check_` will be used. cands = globals() for check_function in sorted([cands[f] for f in cands if callable(cands[f]) and f.startswith(EB_CHECK)]): _log.debug("Adding custom style check %s", check_function) register_check(check_function) styleguide = StyleGuide(quiet=False, config_file=None) options = styleguide.options # we deviate from standard pep8 and allow 120 chars # on a line: the default of 79 is too narrow. options.max_line_length = MAX_LINE_LENGTH # we ignore some tests # note that W291 has been replaced by our custom W299 options.ignore = ( 'W291', # replaced by W299 ) options.verbose = int(verbose) result = styleguide.check_files(easyconfigs) if verbose: result.print_statistics() return result.total_errors
def test_styleguide_continuation_line_outdented(self): pycodestyle.register_check(DummyChecker, ['Z701']) lines = [ 'def foo():\n', ' pass\n', '\n', '\\\n', '\n', 'def bar():\n', ' pass\n', ] pep8style = pycodestyle.StyleGuide() count_errors = pep8style.input_file('stdin', lines=lines) self.assertEqual(count_errors, 2) stdout = sys.stdout.getvalue() expected = ( 'stdin:6:1: ' 'E122 continuation line missing indentation or outdented' ) self.assertTrue(expected in stdout) expected = 'stdin:6:1: E302 expected 2 blank lines, found 1' self.assertTrue(expected in stdout)
def _main(): """Parse options and run checks on Skylark source.""" pycodestyle.register_check(whitespace_around_named_parameter_equals) style_guide = pycodestyle.StyleGuide(parse_argv=True) options = style_guide.options ignore = set(options.ignore) ignore.add('E251') # Skylark wants spaces around named parameters ignore.add('E711') # Skylark has no `is` ignore.add('E721') # Skylark has no `isinstance` options.ignore = tuple(ignore) report = style_guide.check_files() if options.statistics: report.print_statistics() if report.total_errors: if options.count: sys.stderr.write(str(report.total_errors) + '\n') sys.exit(1)
def _register_extensions(): """Register all the extensions.""" extensions = util.OrderedSet() extensions.add(('pycodestyle', pep8.__version__)) parser_hooks = [] options_hooks = [] ignored_hooks = [] try: from pkg_resources import iter_entry_points except ImportError: pass else: for entry in iter_entry_points('flake8.extension'): # Do not verify that the requirements versions are valid checker = _load_entry_point(entry, verify_requirements=False) pep8.register_check(checker, codes=[entry.name]) extensions.add((checker.name, checker.version)) if hasattr(checker, 'add_options'): parser_hooks.append(checker.add_options) if hasattr(checker, 'parse_options'): options_hooks.append(checker.parse_options) if getattr(checker, 'off_by_default', False) is True: ignored_hooks.append(entry.name) return extensions, parser_hooks, options_hooks, ignored_hooks
def test_register_logical_check(self): def check_dummy(logical_line, tokens): if False: yield pycodestyle.register_check(check_dummy, ['Z401']) self.assertTrue(check_dummy in pycodestyle._checks['logical_line']) codes, args = pycodestyle._checks['logical_line'][check_dummy] self.assertTrue('Z401' in codes) self.assertEqual(args, ['logical_line', 'tokens']) pycodestyle.register_check(check_dummy, []) pycodestyle.register_check(check_dummy, ['Z402', 'Z403']) codes, args = pycodestyle._checks['logical_line'][check_dummy] self.assertEqual(codes, ['Z401', 'Z402', 'Z403']) self.assertEqual(args, ['logical_line', 'tokens']) options = pycodestyle.StyleGuide().options self.assertTrue(any(func == check_dummy for name, func, args in options.logical_checks))
def test_register_logical_check(self): def check_dummy(logical_line, tokens): raise NotImplementedError pycodestyle.register_check(check_dummy, ['Z401']) self.assertTrue(check_dummy in pycodestyle._checks['logical_line']) codes, args = pycodestyle._checks['logical_line'][check_dummy] self.assertTrue('Z401' in codes) self.assertEqual(args, ['logical_line', 'tokens']) pycodestyle.register_check(check_dummy, []) pycodestyle.register_check(check_dummy, ['Z402', 'Z403']) codes, args = pycodestyle._checks['logical_line'][check_dummy] self.assertEqual(codes, ['Z401', 'Z402', 'Z403']) self.assertEqual(args, ['logical_line', 'tokens']) options = pycodestyle.StyleGuide().options functions = [func for _, func, _ in options.logical_checks] self.assertIn(check_dummy, functions)
Module implementing the code style checker. """ try: # Only for Py2 import Queue as queue except ImportError: import queue import sys import multiprocessing import pycodestyle from NamingStyleChecker import NamingStyleChecker # register the name checker pycodestyle.register_check(NamingStyleChecker, NamingStyleChecker.Codes) from DocStyleChecker import DocStyleChecker from MiscellaneousChecker import MiscellaneousChecker from ComplexityChecker import ComplexityChecker def initService(): """ Initialize the service and return the entry point. @return the entry point for the background client (function) """ return codeStyleCheck
# This means that we don't have existing config to use. # Make sure pycodestyle's code ignores are fully reset to zero before # adding prospector-flavoured configuration. # pylint: disable=attribute-defined-outside-init self.checker.options.select = () self.checker.options.ignore = tuple( prospector_config.get_disabled_messages("pycodestyle")) if "max-line-length" in prospector_config.tool_options( "pycodestyle"): self.checker.options.max_line_length = prospector_config.tool_options( "pycodestyle")["max-line-length"] else: configured_by = "Configuration found at %s" % external_config # if we have a command line --max-line-length argument, that # overrules everything max_line_length = prospector_config.max_line_length if max_line_length is not None: self.checker.options.max_line_length = max_line_length return configured_by, [] def run(self, _): report = self.checker.check_files() return report.get_messages() # Load pep8ext_naming into pycodestyle's configuration. register_check(NamingChecker)
# -*- coding: utf-8 -*-
def register_checks(): import pycodestyle from sentry.lint.sentry_check import SentryCheck pycodestyle.register_check(SentryCheck)
if not use_config or external_config is None: configured_by = None # This means that we don't have existing config to use. # Make sure pep8's code ignores are fully reset to zero before # adding prospector-flavoured configuration. # pylint: disable=attribute-defined-outside-init self.checker.options.select = () self.checker.options.ignore = tuple(prospector_config.get_disabled_messages('pep8')) if 'max-line-length' in prospector_config.tool_options('pep8'): self.checker.options.max_line_length = \ prospector_config.tool_options('pep8')['max-line-length'] else: configured_by = "Configuration found at %s" % external_config # if we have a command line --max-line-length argument, that # overrules everything max_line_length = prospector_config.max_line_length if max_line_length is not None: self.checker.options.max_line_length = max_line_length return configured_by, [] def run(self, _): report = self.checker.check_files() return report.get_messages() # Load pep8ext_naming into pep8's configuration. register_check(NamingChecker)
import logging import pycodestyle from pylsp import hookimpl, lsp try: from autopep8 import continued_indentation as autopep8_c_i except ImportError: pass else: # Check if autopep8's continued_indentation implementation # is overriding pycodestyle's and if so, re-register # the check using pycodestyle's implementation as expected if autopep8_c_i in pycodestyle._checks['logical_line']: del pycodestyle._checks['logical_line'][autopep8_c_i] pycodestyle.register_check(pycodestyle.continued_indentation) log = logging.getLogger(__name__) @hookimpl def pylsp_lint(workspace, document): config = workspace._config settings = config.plugin_settings('pycodestyle', document_path=document.path) log.debug("Got pycodestyle settings: %s", settings) opts = { 'exclude': settings.get('exclude'), 'filename': settings.get('filename'), 'hang_closing': settings.get('hangClosing'),