Updated the pep8 checker to version 2.1.0dev0.

Sun, 04 Sep 2016 16:50:23 +0200

author
Detlev Offenbach <detlev@die-offenbachs.de>
date
Sun, 04 Sep 2016 16:50:23 +0200
changeset 5146
f96c32abd120
parent 5145
95947ce71171
child 5147
d39dd5cee0c8

Updated the pep8 checker to version 2.1.0dev0.

Documentation/Source/eric6.Plugins.CheckerPlugins.CodeStyleChecker.pep8.html file | annotate | diff | comparison | revisions
Plugins/CheckerPlugins/CodeStyleChecker/pep8.py file | annotate | diff | comparison | revisions
Plugins/CheckerPlugins/CodeStyleChecker/translations.py file | annotate | diff | comparison | revisions
--- a/Documentation/Source/eric6.Plugins.CheckerPlugins.CodeStyleChecker.pep8.html	Sun Sep 04 14:34:56 2016 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1426 +0,0 @@
-<!DOCTYPE html>
-<html><head>
-<title>eric6.Plugins.CheckerPlugins.CodeStyleChecker.pep8</title>
-<meta charset="UTF-8">
-<style>
-body {
-    background: #EDECE6;
-    margin: 0em 1em 10em 1em;
-    color: black;
-}
-
-h1 { color: white; background: #85774A; }
-h2 { color: white; background: #85774A; }
-h3 { color: white; background: #9D936E; }
-h4 { color: white; background: #9D936E; }
-    
-a { color: #BA6D36; }
-
-</style>
-</head>
-<body><a NAME="top" ID="top"></a>
-<h1>eric6.Plugins.CheckerPlugins.CodeStyleChecker.pep8</h1>
-
-<h3>Global Attributes</h3>
-<table>
-<tr><td>ARITHMETIC_OP</td></tr><tr><td>BENCHMARK_KEYS</td></tr><tr><td>COMMENT_WITH_NL</td></tr><tr><td>COMPARE_NEGATIVE_REGEX</td></tr><tr><td>COMPARE_SINGLETON_REGEX</td></tr><tr><td>COMPARE_TYPE_REGEX</td></tr><tr><td>DEFAULT_EXCLUDE</td></tr><tr><td>DEFAULT_IGNORE</td></tr><tr><td>DOCSTRING_REGEX</td></tr><tr><td>ERRORCODE_REGEX</td></tr><tr><td>EXTRANEOUS_WHITESPACE_REGEX</td></tr><tr><td>HUNK_REGEX</td></tr><tr><td>INDENT_REGEX</td></tr><tr><td>KEYWORDS</td></tr><tr><td>KEYWORD_REGEX</td></tr><tr><td>LAMBDA_REGEX</td></tr><tr><td>MAX_LINE_LENGTH</td></tr><tr><td>NEWLINE</td></tr><tr><td>OPERATOR_REGEX</td></tr><tr><td>PROJECT_CONFIG</td></tr><tr><td>RAISE_COMMA_REGEX</td></tr><tr><td>REPORT_FORMAT</td></tr><tr><td>RERAISE_COMMA_REGEX</td></tr><tr><td>SINGLETONS</td></tr><tr><td>SKIP_COMMENTS</td></tr><tr><td>SKIP_TOKENS</td></tr><tr><td>TESTSUITE_PATH</td></tr><tr><td>UNARY_OPERATORS</td></tr><tr><td>WHITESPACE</td></tr><tr><td>WHITESPACE_AFTER_COMMA_REGEX</td></tr><tr><td>WS_NEEDED_OPERATORS</td></tr><tr><td>WS_OPTIONAL_OPERATORS</td></tr><tr><td>__version__</td></tr><tr><td>_checks</td></tr><tr><td>noqa</td></tr>
-</table>
-<h3>Classes</h3>
-<table>
-<tr>
-<td><a href="#BaseReport">BaseReport</a></td>
-<td>Collect the results of the checks.</td>
-</tr><tr>
-<td><a href="#Checker">Checker</a></td>
-<td>Load a Python source file, tokenize it, check coding style.</td>
-</tr><tr>
-<td><a href="#DiffReport">DiffReport</a></td>
-<td>Collect and print the results for the changed lines only.</td>
-</tr><tr>
-<td><a href="#FileReport">FileReport</a></td>
-<td>Collect the results of the checks and print only the filenames.</td>
-</tr><tr>
-<td><a href="#StandardReport">StandardReport</a></td>
-<td>Collect and print the results of the checks.</td>
-</tr><tr>
-<td><a href="#StyleGuide">StyleGuide</a></td>
-<td>Initialize a PEP-8 instance with few options.</td>
-</tr>
-</table>
-<h3>Functions</h3>
-<table>
-<tr>
-<td><a href="#_add_check">_add_check</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#_get_parameters">_get_parameters</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#_is_eol_token">_is_eol_token</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#_is_eol_token_1">_is_eol_token</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#_main">_main</a></td>
-<td>Parse options and run checks on Python source.</td>
-</tr><tr>
-<td><a href="#_parse_multi_options">_parse_multi_options</a></td>
-<td>Split and strip and discard empties.</td>
-</tr><tr>
-<td><a href="#blank_lines">blank_lines</a></td>
-<td>Separate top-level function and class definitions with two blank lines.</td>
-</tr><tr>
-<td><a href="#break_around_binary_operator">break_around_binary_operator</a></td>
-<td>Avoid breaks before binary operators.</td>
-</tr><tr>
-<td><a href="#comparison_negative">comparison_negative</a></td>
-<td>Negative comparison should be done using "not in" and "is not".</td>
-</tr><tr>
-<td><a href="#comparison_to_singleton">comparison_to_singleton</a></td>
-<td>Comparison to singletons should use "is" or "is not".</td>
-</tr><tr>
-<td><a href="#comparison_type">comparison_type</a></td>
-<td>Object type comparisons should always use isinstance().</td>
-</tr><tr>
-<td><a href="#compound_statements">compound_statements</a></td>
-<td>Compound statements (on the same line) are generally discouraged.</td>
-</tr><tr>
-<td><a href="#continued_indentation">continued_indentation</a></td>
-<td>Continuation lines indentation.</td>
-</tr><tr>
-<td><a href="#expand_indent">expand_indent</a></td>
-<td>Return the amount of indentation.</td>
-</tr><tr>
-<td><a href="#explicit_line_join">explicit_line_join</a></td>
-<td>Avoid explicit line join between brackets.</td>
-</tr><tr>
-<td><a href="#extraneous_whitespace">extraneous_whitespace</a></td>
-<td>Avoid extraneous whitespace.</td>
-</tr><tr>
-<td><a href="#filename_match">filename_match</a></td>
-<td>Check if patterns contains a pattern that matches filename.</td>
-</tr><tr>
-<td><a href="#get_parser">get_parser</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#imports_on_separate_lines">imports_on_separate_lines</a></td>
-<td>Imports should usually be on separate lines.</td>
-</tr><tr>
-<td><a href="#indentation">indentation</a></td>
-<td>Use 4 spaces per indentation level.</td>
-</tr><tr>
-<td><a href="#init_checks_registry">init_checks_registry</a></td>
-<td>Register all globally visible functions.</td>
-</tr><tr>
-<td><a href="#is_binary_operator">is_binary_operator</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#is_string_literal">is_string_literal</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#maximum_line_length">maximum_line_length</a></td>
-<td>Limit all lines to a maximum of 79 characters.</td>
-</tr><tr>
-<td><a href="#missing_whitespace">missing_whitespace</a></td>
-<td>Each comma, semicolon or colon should be followed by whitespace.</td>
-</tr><tr>
-<td><a href="#missing_whitespace_around_operator">missing_whitespace_around_operator</a></td>
-<td>Surround operators with a single space on either side.</td>
-</tr><tr>
-<td><a href="#module_imports_on_top_of_file">module_imports_on_top_of_file</a></td>
-<td>Imports are always put at the top of the file, just after any module comments and docstrings, and before module globals and constants.</td>
-</tr><tr>
-<td><a href="#mute_string">mute_string</a></td>
-<td>Replace contents with 'xxx' to prevent syntax matching.</td>
-</tr><tr>
-<td><a href="#normalize_paths">normalize_paths</a></td>
-<td>Parse a comma-separated list of paths.</td>
-</tr><tr>
-<td><a href="#parse_udiff">parse_udiff</a></td>
-<td>Return a dictionary of matching lines.</td>
-</tr><tr>
-<td><a href="#process_options">process_options</a></td>
-<td>Process options passed either via arglist or via command line args.</td>
-</tr><tr>
-<td><a href="#python_3000_backticks">python_3000_backticks</a></td>
-<td>Backticks are removed in Python 3: use repr() instead.</td>
-</tr><tr>
-<td><a href="#python_3000_has_key">python_3000_has_key</a></td>
-<td>The {}.has_key() method is removed in Python 3: use the 'in' operator.</td>
-</tr><tr>
-<td><a href="#python_3000_not_equal">python_3000_not_equal</a></td>
-<td>New code should always use != instead of <>.</td>
-</tr><tr>
-<td><a href="#python_3000_raise_comma">python_3000_raise_comma</a></td>
-<td>When raising an exception, use "raise ValueError('message')".</td>
-</tr><tr>
-<td><a href="#read_config">read_config</a></td>
-<td>Read and parse configurations</td>
-</tr><tr>
-<td><a href="#readlines">readlines</a></td>
-<td>Read the source code.</td>
-</tr><tr>
-<td><a href="#readlines_1">readlines</a></td>
-<td>Read the source code.</td>
-</tr><tr>
-<td><a href="#register_check">register_check</a></td>
-<td>Register a new check object.</td>
-</tr><tr>
-<td><a href="#stdin_get_value">stdin_get_value</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#tabs_obsolete">tabs_obsolete</a></td>
-<td>For new projects, spaces-only are strongly recommended over tabs.</td>
-</tr><tr>
-<td><a href="#tabs_or_spaces">tabs_or_spaces</a></td>
-<td>Never mix tabs and spaces.</td>
-</tr><tr>
-<td><a href="#trailing_blank_lines">trailing_blank_lines</a></td>
-<td>Trailing blank lines are superfluous.</td>
-</tr><tr>
-<td><a href="#trailing_whitespace">trailing_whitespace</a></td>
-<td>Trailing whitespace is superfluous.</td>
-</tr><tr>
-<td><a href="#whitespace_around_comma">whitespace_around_comma</a></td>
-<td>Avoid extraneous whitespace after a comma or a colon.</td>
-</tr><tr>
-<td><a href="#whitespace_around_keywords">whitespace_around_keywords</a></td>
-<td>Avoid extraneous whitespace around keywords.</td>
-</tr><tr>
-<td><a href="#whitespace_around_named_parameter_equals">whitespace_around_named_parameter_equals</a></td>
-<td>Don't use spaces around the '=' sign in function arguments.</td>
-</tr><tr>
-<td><a href="#whitespace_around_operator">whitespace_around_operator</a></td>
-<td>Avoid extraneous whitespace around an operator.</td>
-</tr><tr>
-<td><a href="#whitespace_before_comment">whitespace_before_comment</a></td>
-<td>Separate inline comments by at least two spaces.</td>
-</tr><tr>
-<td><a href="#whitespace_before_parameters">whitespace_before_parameters</a></td>
-<td>Avoid extraneous whitespace.</td>
-</tr>
-</table>
-<hr /><hr />
-<a NAME="BaseReport" ID="BaseReport"></a>
-<h2>BaseReport</h2>
-<p>
-Collect the results of the checks.
-</p>
-<h3>Derived from</h3>
-object
-<h3>Class Attributes</h3>
-<table>
-<tr><td>print_filename</td></tr>
-</table>
-<h3>Class Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Methods</h3>
-<table>
-<tr>
-<td><a href="#BaseReport.__init__">BaseReport</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#BaseReport.error">error</a></td>
-<td>Report an error, according to options.</td>
-</tr><tr>
-<td><a href="#BaseReport.error_args">error_args</a></td>
-<td>Report an error, according to options.</td>
-</tr><tr>
-<td><a href="#BaseReport.get_count">get_count</a></td>
-<td>Return the total count of errors and warnings.</td>
-</tr><tr>
-<td><a href="#BaseReport.get_file_results">get_file_results</a></td>
-<td>Return the count of errors and warnings for this file.</td>
-</tr><tr>
-<td><a href="#BaseReport.get_statistics">get_statistics</a></td>
-<td>Get statistics for message codes that start with the prefix.</td>
-</tr><tr>
-<td><a href="#BaseReport.increment_logical_line">increment_logical_line</a></td>
-<td>Signal a new logical line.</td>
-</tr><tr>
-<td><a href="#BaseReport.init_file">init_file</a></td>
-<td>Signal a new file.</td>
-</tr><tr>
-<td><a href="#BaseReport.print_benchmark">print_benchmark</a></td>
-<td>Print benchmark numbers.</td>
-</tr><tr>
-<td><a href="#BaseReport.print_statistics">print_statistics</a></td>
-<td>Print overall statistics (number of errors and warnings).</td>
-</tr><tr>
-<td><a href="#BaseReport.start">start</a></td>
-<td>Start the timer.</td>
-</tr><tr>
-<td><a href="#BaseReport.stop">stop</a></td>
-<td>Stop the timer.</td>
-</tr>
-</table>
-<h3>Static Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<a NAME="BaseReport.__init__" ID="BaseReport.__init__"></a>
-<h4>BaseReport (Constructor)</h4>
-<b>BaseReport</b>(<i>options</i>)
-<a NAME="BaseReport.error" ID="BaseReport.error"></a>
-<h4>BaseReport.error</h4>
-<b>error</b>(<i>line_number, offset, text, check</i>)
-<p>
-Report an error, according to options.
-</p><a NAME="BaseReport.error_args" ID="BaseReport.error_args"></a>
-<h4>BaseReport.error_args</h4>
-<b>error_args</b>(<i>line_number, offset, text, check, *args</i>)
-<p>
-Report an error, according to options.
-</p><a NAME="BaseReport.get_count" ID="BaseReport.get_count"></a>
-<h4>BaseReport.get_count</h4>
-<b>get_count</b>(<i>prefix=''</i>)
-<p>
-Return the total count of errors and warnings.
-</p><a NAME="BaseReport.get_file_results" ID="BaseReport.get_file_results"></a>
-<h4>BaseReport.get_file_results</h4>
-<b>get_file_results</b>(<i></i>)
-<p>
-Return the count of errors and warnings for this file.
-</p><a NAME="BaseReport.get_statistics" ID="BaseReport.get_statistics"></a>
-<h4>BaseReport.get_statistics</h4>
-<b>get_statistics</b>(<i>prefix=''</i>)
-<p>
-Get statistics for message codes that start with the prefix.
-</p><p>
-        prefix='' matches all errors and warnings
-        prefix='E' matches all errors
-        prefix='W' matches all warnings
-        prefix='E4' matches all errors that have to do with imports
-</p><a NAME="BaseReport.increment_logical_line" ID="BaseReport.increment_logical_line"></a>
-<h4>BaseReport.increment_logical_line</h4>
-<b>increment_logical_line</b>(<i></i>)
-<p>
-Signal a new logical line.
-</p><a NAME="BaseReport.init_file" ID="BaseReport.init_file"></a>
-<h4>BaseReport.init_file</h4>
-<b>init_file</b>(<i>filename, lines, expected, line_offset</i>)
-<p>
-Signal a new file.
-</p><a NAME="BaseReport.print_benchmark" ID="BaseReport.print_benchmark"></a>
-<h4>BaseReport.print_benchmark</h4>
-<b>print_benchmark</b>(<i></i>)
-<p>
-Print benchmark numbers.
-</p><a NAME="BaseReport.print_statistics" ID="BaseReport.print_statistics"></a>
-<h4>BaseReport.print_statistics</h4>
-<b>print_statistics</b>(<i>prefix=''</i>)
-<p>
-Print overall statistics (number of errors and warnings).
-</p><a NAME="BaseReport.start" ID="BaseReport.start"></a>
-<h4>BaseReport.start</h4>
-<b>start</b>(<i></i>)
-<p>
-Start the timer.
-</p><a NAME="BaseReport.stop" ID="BaseReport.stop"></a>
-<h4>BaseReport.stop</h4>
-<b>stop</b>(<i></i>)
-<p>
-Stop the timer.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="Checker" ID="Checker"></a>
-<h2>Checker</h2>
-<p>
-Load a Python source file, tokenize it, check coding style.
-</p>
-<h3>Derived from</h3>
-object
-<h3>Class Attributes</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Class Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Methods</h3>
-<table>
-<tr>
-<td><a href="#Checker.__init__">Checker</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#Checker.build_tokens_line">build_tokens_line</a></td>
-<td>Build a logical line from tokens.</td>
-</tr><tr>
-<td><a href="#Checker.check_all">check_all</a></td>
-<td>Run all checks on the input file.</td>
-</tr><tr>
-<td><a href="#Checker.check_ast">check_ast</a></td>
-<td>Build the file's AST and run all AST checks.</td>
-</tr><tr>
-<td><a href="#Checker.check_logical">check_logical</a></td>
-<td>Build a line from tokens and run all logical checks on it.</td>
-</tr><tr>
-<td><a href="#Checker.check_physical">check_physical</a></td>
-<td>Run all physical checks on a raw input line.</td>
-</tr><tr>
-<td><a href="#Checker.generate_tokens">generate_tokens</a></td>
-<td>Tokenize the file, run physical line checks and yield tokens.</td>
-</tr><tr>
-<td><a href="#Checker.init_checker_state">init_checker_state</a></td>
-<td>Prepares a custom state for the specific checker plugin.</td>
-</tr><tr>
-<td><a href="#Checker.maybe_check_physical">maybe_check_physical</a></td>
-<td>If appropriate (based on token), check current physical line(s).</td>
-</tr><tr>
-<td><a href="#Checker.readline">readline</a></td>
-<td>Get the next line from the input buffer.</td>
-</tr><tr>
-<td><a href="#Checker.report_invalid_syntax">report_invalid_syntax</a></td>
-<td>Check if the syntax is valid.</td>
-</tr><tr>
-<td><a href="#Checker.run_check">run_check</a></td>
-<td>Run a check plugin.</td>
-</tr>
-</table>
-<h3>Static Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<a NAME="Checker.__init__" ID="Checker.__init__"></a>
-<h4>Checker (Constructor)</h4>
-<b>Checker</b>(<i>filename=None, lines=None, options=None, report=None, **kwargs</i>)
-<a NAME="Checker.build_tokens_line" ID="Checker.build_tokens_line"></a>
-<h4>Checker.build_tokens_line</h4>
-<b>build_tokens_line</b>(<i></i>)
-<p>
-Build a logical line from tokens.
-</p><a NAME="Checker.check_all" ID="Checker.check_all"></a>
-<h4>Checker.check_all</h4>
-<b>check_all</b>(<i>expected=None, line_offset=0</i>)
-<p>
-Run all checks on the input file.
-</p><a NAME="Checker.check_ast" ID="Checker.check_ast"></a>
-<h4>Checker.check_ast</h4>
-<b>check_ast</b>(<i></i>)
-<p>
-Build the file's AST and run all AST checks.
-</p><a NAME="Checker.check_logical" ID="Checker.check_logical"></a>
-<h4>Checker.check_logical</h4>
-<b>check_logical</b>(<i></i>)
-<p>
-Build a line from tokens and run all logical checks on it.
-</p><a NAME="Checker.check_physical" ID="Checker.check_physical"></a>
-<h4>Checker.check_physical</h4>
-<b>check_physical</b>(<i>line</i>)
-<p>
-Run all physical checks on a raw input line.
-</p><a NAME="Checker.generate_tokens" ID="Checker.generate_tokens"></a>
-<h4>Checker.generate_tokens</h4>
-<b>generate_tokens</b>(<i></i>)
-<p>
-Tokenize the file, run physical line checks and yield tokens.
-</p><a NAME="Checker.init_checker_state" ID="Checker.init_checker_state"></a>
-<h4>Checker.init_checker_state</h4>
-<b>init_checker_state</b>(<i>name, argument_names</i>)
-<p>
- Prepares a custom state for the specific checker plugin.
-</p><a NAME="Checker.maybe_check_physical" ID="Checker.maybe_check_physical"></a>
-<h4>Checker.maybe_check_physical</h4>
-<b>maybe_check_physical</b>(<i>token</i>)
-<p>
-If appropriate (based on token), check current physical line(s).
-</p><a NAME="Checker.readline" ID="Checker.readline"></a>
-<h4>Checker.readline</h4>
-<b>readline</b>(<i></i>)
-<p>
-Get the next line from the input buffer.
-</p><a NAME="Checker.report_invalid_syntax" ID="Checker.report_invalid_syntax"></a>
-<h4>Checker.report_invalid_syntax</h4>
-<b>report_invalid_syntax</b>(<i></i>)
-<p>
-Check if the syntax is valid.
-</p><a NAME="Checker.run_check" ID="Checker.run_check"></a>
-<h4>Checker.run_check</h4>
-<b>run_check</b>(<i>check, argument_names</i>)
-<p>
-Run a check plugin.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="DiffReport" ID="DiffReport"></a>
-<h2>DiffReport</h2>
-<p>
-Collect and print the results for the changed lines only.
-</p>
-<h3>Derived from</h3>
-StandardReport
-<h3>Class Attributes</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Class Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Methods</h3>
-<table>
-<tr>
-<td><a href="#DiffReport.__init__">DiffReport</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#DiffReport.error">error</a></td>
-<td></td>
-</tr>
-</table>
-<h3>Static Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<a NAME="DiffReport.__init__" ID="DiffReport.__init__"></a>
-<h4>DiffReport (Constructor)</h4>
-<b>DiffReport</b>(<i>options</i>)
-<a NAME="DiffReport.error" ID="DiffReport.error"></a>
-<h4>DiffReport.error</h4>
-<b>error</b>(<i>line_number, offset, text, check</i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="FileReport" ID="FileReport"></a>
-<h2>FileReport</h2>
-<p>
-Collect the results of the checks and print only the filenames.
-</p>
-<h3>Derived from</h3>
-BaseReport
-<h3>Class Attributes</h3>
-<table>
-<tr><td>print_filename</td></tr>
-</table>
-<h3>Class Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Static Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="StandardReport" ID="StandardReport"></a>
-<h2>StandardReport</h2>
-<p>
-Collect and print the results of the checks.
-</p>
-<h3>Derived from</h3>
-BaseReport
-<h3>Class Attributes</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Class Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Methods</h3>
-<table>
-<tr>
-<td><a href="#StandardReport.__init__">StandardReport</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#StandardReport.error">error</a></td>
-<td>Report an error, according to options.</td>
-</tr><tr>
-<td><a href="#StandardReport.error_args">error_args</a></td>
-<td>Report an error, according to options.</td>
-</tr><tr>
-<td><a href="#StandardReport.get_file_results">get_file_results</a></td>
-<td>Print the result and return the overall count for this file.</td>
-</tr><tr>
-<td><a href="#StandardReport.init_file">init_file</a></td>
-<td>Signal a new file.</td>
-</tr>
-</table>
-<h3>Static Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<a NAME="StandardReport.__init__" ID="StandardReport.__init__"></a>
-<h4>StandardReport (Constructor)</h4>
-<b>StandardReport</b>(<i>options</i>)
-<a NAME="StandardReport.error" ID="StandardReport.error"></a>
-<h4>StandardReport.error</h4>
-<b>error</b>(<i>line_number, offset, text, check</i>)
-<p>
-Report an error, according to options.
-</p><a NAME="StandardReport.error_args" ID="StandardReport.error_args"></a>
-<h4>StandardReport.error_args</h4>
-<b>error_args</b>(<i>line_number, offset, code, check, *args</i>)
-<p>
-Report an error, according to options.
-</p><a NAME="StandardReport.get_file_results" ID="StandardReport.get_file_results"></a>
-<h4>StandardReport.get_file_results</h4>
-<b>get_file_results</b>(<i></i>)
-<p>
-Print the result and return the overall count for this file.
-</p><a NAME="StandardReport.init_file" ID="StandardReport.init_file"></a>
-<h4>StandardReport.init_file</h4>
-<b>init_file</b>(<i>filename, lines, expected, line_offset</i>)
-<p>
-Signal a new file.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="StyleGuide" ID="StyleGuide"></a>
-<h2>StyleGuide</h2>
-<p>
-Initialize a PEP-8 instance with few options.
-</p>
-<h3>Derived from</h3>
-object
-<h3>Class Attributes</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Class Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Methods</h3>
-<table>
-<tr>
-<td><a href="#StyleGuide.__init__">StyleGuide</a></td>
-<td></td>
-</tr><tr>
-<td><a href="#StyleGuide.check_files">check_files</a></td>
-<td>Run all checks on the paths.</td>
-</tr><tr>
-<td><a href="#StyleGuide.excluded">excluded</a></td>
-<td>Check if the file should be excluded.</td>
-</tr><tr>
-<td><a href="#StyleGuide.get_checks">get_checks</a></td>
-<td>Get all the checks for this category.</td>
-</tr><tr>
-<td><a href="#StyleGuide.ignore_code">ignore_code</a></td>
-<td>Check if the error code should be ignored.</td>
-</tr><tr>
-<td><a href="#StyleGuide.init_report">init_report</a></td>
-<td>Initialize the report instance.</td>
-</tr><tr>
-<td><a href="#StyleGuide.input_dir">input_dir</a></td>
-<td>Check all files in this directory and all subdirectories.</td>
-</tr><tr>
-<td><a href="#StyleGuide.input_file">input_file</a></td>
-<td>Run all checks on a Python source file.</td>
-</tr>
-</table>
-<h3>Static Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<a NAME="StyleGuide.__init__" ID="StyleGuide.__init__"></a>
-<h4>StyleGuide (Constructor)</h4>
-<b>StyleGuide</b>(<i>*args, **kwargs</i>)
-<a NAME="StyleGuide.check_files" ID="StyleGuide.check_files"></a>
-<h4>StyleGuide.check_files</h4>
-<b>check_files</b>(<i>paths=None</i>)
-<p>
-Run all checks on the paths.
-</p><a NAME="StyleGuide.excluded" ID="StyleGuide.excluded"></a>
-<h4>StyleGuide.excluded</h4>
-<b>excluded</b>(<i>filename, parent=None</i>)
-<p>
-Check if the file should be excluded.
-</p><p>
-        Check if 'options.exclude' contains a pattern that matches filename.
-</p><a NAME="StyleGuide.get_checks" ID="StyleGuide.get_checks"></a>
-<h4>StyleGuide.get_checks</h4>
-<b>get_checks</b>(<i>argument_name</i>)
-<p>
-Get all the checks for this category.
-</p><p>
-        Find all globally visible functions where the first argument name
-        starts with argument_name and which contain selected tests.
-</p><a NAME="StyleGuide.ignore_code" ID="StyleGuide.ignore_code"></a>
-<h4>StyleGuide.ignore_code</h4>
-<b>ignore_code</b>(<i>code</i>)
-<p>
-Check if the error code should be ignored.
-</p><p>
-        If 'options.select' contains a prefix of the error code,
-        return False.  Else, if 'options.ignore' contains a prefix of
-        the error code, return True.
-</p><a NAME="StyleGuide.init_report" ID="StyleGuide.init_report"></a>
-<h4>StyleGuide.init_report</h4>
-<b>init_report</b>(<i>reporter=None</i>)
-<p>
-Initialize the report instance.
-</p><a NAME="StyleGuide.input_dir" ID="StyleGuide.input_dir"></a>
-<h4>StyleGuide.input_dir</h4>
-<b>input_dir</b>(<i>dirname</i>)
-<p>
-Check all files in this directory and all subdirectories.
-</p><a NAME="StyleGuide.input_file" ID="StyleGuide.input_file"></a>
-<h4>StyleGuide.input_file</h4>
-<b>input_file</b>(<i>filename, lines=None, expected=None, line_offset=0</i>)
-<p>
-Run all checks on a Python source file.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="_add_check" ID="_add_check"></a>
-<h2>_add_check</h2>
-<b>_add_check</b>(<i>check, kind, codes, args</i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="_get_parameters" ID="_get_parameters"></a>
-<h2>_get_parameters</h2>
-<b>_get_parameters</b>(<i>function</i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="_is_eol_token" ID="_is_eol_token"></a>
-<h2>_is_eol_token</h2>
-<b>_is_eol_token</b>(<i>token</i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="_is_eol_token_1" ID="_is_eol_token_1"></a>
-<h2>_is_eol_token</h2>
-<b>_is_eol_token</b>(<i>token, _eol_token=_is_eol_token</i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="_main" ID="_main"></a>
-<h2>_main</h2>
-<b>_main</b>(<i></i>)
-<p>
-Parse options and run checks on Python source.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="_parse_multi_options" ID="_parse_multi_options"></a>
-<h2>_parse_multi_options</h2>
-<b>_parse_multi_options</b>(<i>options, split_token=', '</i>)
-<p>
-Split and strip and discard empties.
-</p><p>
-    Turns the following:
-</p><p>
-    A,
-    B,
-</p><p>
-    into ["A", "B"]
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="blank_lines" ID="blank_lines"></a>
-<h2>blank_lines</h2>
-<b>blank_lines</b>(<i>logical_line, blank_lines, indent_level, line_number, blank_before, previous_logical, previous_indent_level</i>)
-<p>
-Separate top-level function and class definitions with two blank lines.
-</p><p>
-    Method definitions inside a class are separated by a single blank line.
-</p><p>
-    Extra blank lines may be used (sparingly) to separate groups of related
-    functions.  Blank lines may be omitted between a bunch of related
-    one-liners (e.g. a set of dummy implementations).
-</p><p>
-    Use blank lines in functions, sparingly, to indicate logical sections.
-</p><p>
-    Okay: def a():\n    pass\n\n\ndef b():\n    pass
-    Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
-</p><p>
-    E301: class Foo:\n    b = 0\n    def bar():\n        pass
-    E302: def a():\n    pass\n\ndef b(n):\n    pass
-    E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
-    E303: def a():\n\n\n\n    pass
-    E304: @decorator\n\ndef a():\n    pass
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="break_around_binary_operator" ID="break_around_binary_operator"></a>
-<h2>break_around_binary_operator</h2>
-<b>break_around_binary_operator</b>(<i>logical_line, tokens</i>)
-<p>
-    Avoid breaks before binary operators.
-</p><p>
-    The preferred place to break around a binary operator is after the
-    operator, not before it.
-</p><p>
-    W503: (width == 0\n + height == 0)
-    W503: (width == 0\n and height == 0)
-</p><p>
-    Okay: (width == 0 +\n height == 0)
-    Okay: foo(\n    -x)
-    Okay: foo(x\n    [])
-    Okay: x = '''\n''' + ''
-    Okay: foo(x,\n    -y)
-    Okay: foo(x,  # comment\n    -y)
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="comparison_negative" ID="comparison_negative"></a>
-<h2>comparison_negative</h2>
-<b>comparison_negative</b>(<i>logical_line</i>)
-<p>
-Negative comparison should be done using "not in" and "is not".
-</p><p>
-    Okay: if x not in y:\n    pass
-    Okay: assert (X in Y or X is Z)
-    Okay: if not (X in Y):\n    pass
-    Okay: zz = x is not y
-    E713: Z = not X in Y
-    E713: if not X.B in Y:\n    pass
-    E714: if not X is Y:\n    pass
-    E714: Z = not X.B is Y
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="comparison_to_singleton" ID="comparison_to_singleton"></a>
-<h2>comparison_to_singleton</h2>
-<b>comparison_to_singleton</b>(<i>logical_line, noqa</i>)
-<p>
-Comparison to singletons should use "is" or "is not".
-</p><p>
-    Comparisons to singletons like None should always be done
-    with "is" or "is not", never the equality operators.
-</p><p>
-    Okay: if arg is not None:
-    E711: if arg != None:
-    E711: if None == arg:
-    E712: if arg == True:
-    E712: if False == arg:
-</p><p>
-    Also, beware of writing if x when you really mean if x is not None --
-    e.g. when testing whether a variable or argument that defaults to None was
-    set to some other value.  The other value might have a type (such as a
-    container) that could be false in a boolean context!
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="comparison_type" ID="comparison_type"></a>
-<h2>comparison_type</h2>
-<b>comparison_type</b>(<i>logical_line, noqa</i>)
-<p>
-Object type comparisons should always use isinstance().
-</p><p>
-    Do not compare types directly.
-</p><p>
-    Okay: if isinstance(obj, int):
-    E721: if type(obj) is type(1):
-</p><p>
-    When checking if an object is a string, keep in mind that it might be a
-    unicode string too! In Python 2.3, str and unicode have a common base
-    class, basestring, so you can do:
-</p><p>
-    Okay: if isinstance(obj, basestring):
-    Okay: if type(a1) is type(b1):
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="compound_statements" ID="compound_statements"></a>
-<h2>compound_statements</h2>
-<b>compound_statements</b>(<i>logical_line</i>)
-<p>
-Compound statements (on the same line) are generally discouraged.
-</p><p>
-    While sometimes it's okay to put an if/for/while with a small body
-    on the same line, never do this for multi-clause statements.
-    Also avoid folding such long lines!
-</p><p>
-    Always use a def statement instead of an assignment statement that
-    binds a lambda expression directly to a name.
-</p><p>
-    Okay: if foo == 'blah':\n    do_blah_thing()
-    Okay: do_one()
-    Okay: do_two()
-    Okay: do_three()
-</p><p>
-    E701: if foo == 'blah': do_blah_thing()
-    E701: for x in lst: total += x
-    E701: while t < 10: t = delay()
-    E701: if foo == 'blah': do_blah_thing()
-    E701: else: do_non_blah_thing()
-    E701: try: something()
-    E701: finally: cleanup()
-    E701: if foo == 'blah': one(); two(); three()
-    E702: do_one(); do_two(); do_three()
-    E703: do_four();  # useless semicolon
-    E704: def f(x): return 2*x
-    E731: f = lambda x: 2*x
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="continued_indentation" ID="continued_indentation"></a>
-<h2>continued_indentation</h2>
-<b>continued_indentation</b>(<i>logical_line, tokens, indent_level, hang_closing, indent_char, noqa, verbose</i>)
-<p>
-Continuation lines indentation.
-</p><p>
-    Continuation lines should align wrapped elements either vertically
-    using Python's implicit line joining inside parentheses, brackets
-    and braces, or using a hanging indent.
-</p><p>
-    When using a hanging indent these considerations should be applied:
-    - there should be no arguments on the first line, and
-    - further indentation should be used to clearly distinguish itself as a
-      continuation line.
-</p><p>
-    Okay: a = (\n)
-    E123: a = (\n    )
-</p><p>
-    Okay: a = (\n    42)
-    E121: a = (\n   42)
-    E122: a = (\n42)
-    E123: a = (\n    42\n    )
-    E124: a = (24,\n     42\n)
-    E125: if (\n    b):\n    pass
-    E126: a = (\n        42)
-    E127: a = (24,\n      42)
-    E128: a = (24,\n    42)
-    E129: if (a or\n    b):\n    pass
-    E131: a = (\n    42\n 24)
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="expand_indent" ID="expand_indent"></a>
-<h2>expand_indent</h2>
-<b>expand_indent</b>(<i>line</i>)
-<p>
-Return the amount of indentation.
-</p><p>
-    Tabs are expanded to the next multiple of 8.
-</p><p>
-    >>> expand_indent('    ')
-    4
-    >>> expand_indent('\t')
-    8
-    >>> expand_indent('       \t')
-    8
-    >>> expand_indent('        \t')
-    16
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="explicit_line_join" ID="explicit_line_join"></a>
-<h2>explicit_line_join</h2>
-<b>explicit_line_join</b>(<i>logical_line, tokens</i>)
-<p>
-Avoid explicit line join between brackets.
-</p><p>
-    The preferred way of wrapping long lines is by using Python's implied line
-    continuation inside parentheses, brackets and braces.  Long lines can be
-    broken over multiple lines by wrapping expressions in parentheses.  These
-    should be used in preference to using a backslash for line continuation.
-</p><p>
-    E502: aaa = [123, \\n       123]
-    E502: aaa = ("bbb " \\n       "ccc")
-</p><p>
-    Okay: aaa = [123,\n       123]
-    Okay: aaa = ("bbb "\n       "ccc")
-    Okay: aaa = "bbb " \\n    "ccc"
-    Okay: aaa = 123  # \\
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="extraneous_whitespace" ID="extraneous_whitespace"></a>
-<h2>extraneous_whitespace</h2>
-<b>extraneous_whitespace</b>(<i>logical_line</i>)
-<p>
-Avoid extraneous whitespace.
-</p><p>
-    Avoid extraneous whitespace in these situations:
-    - Immediately inside parentheses, brackets or braces.
-    - Immediately before a comma, semicolon, or colon.
-</p><p>
-    Okay: spam(ham[1], {eggs: 2})
-    E201: spam( ham[1], {eggs: 2})
-    E201: spam(ham[ 1], {eggs: 2})
-    E201: spam(ham[1], { eggs: 2})
-    E202: spam(ham[1], {eggs: 2} )
-    E202: spam(ham[1 ], {eggs: 2})
-    E202: spam(ham[1], {eggs: 2 })
-</p><p>
-    E203: if x == 4: print x, y; x, y = y , x
-    E203: if x == 4: print x, y ; x, y = y, x
-    E203: if x == 4 : print x, y; x, y = y, x
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="filename_match" ID="filename_match"></a>
-<h2>filename_match</h2>
-<b>filename_match</b>(<i>filename, patterns, default=True</i>)
-<p>
-Check if patterns contains a pattern that matches filename.
-</p><p>
-    If patterns is unspecified, this always returns True.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="get_parser" ID="get_parser"></a>
-<h2>get_parser</h2>
-<b>get_parser</b>(<i>prog='pep8', version=__version__</i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="imports_on_separate_lines" ID="imports_on_separate_lines"></a>
-<h2>imports_on_separate_lines</h2>
-<b>imports_on_separate_lines</b>(<i>logical_line</i>)
-<p>
-Imports should usually be on separate lines.
-</p><p>
-    Okay: import os\nimport sys
-    E401: import sys, os
-</p><p>
-    Okay: from subprocess import Popen, PIPE
-    Okay: from myclas import MyClass
-    Okay: from foo.bar.yourclass import YourClass
-    Okay: import myclass
-    Okay: import foo.bar.yourclass
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="indentation" ID="indentation"></a>
-<h2>indentation</h2>
-<b>indentation</b>(<i>logical_line, previous_logical, indent_char, indent_level, previous_indent_level</i>)
-<p>
-Use 4 spaces per indentation level.
-</p><p>
-    For really old code that you don't want to mess up, you can continue to
-    use 8-space tabs.
-</p><p>
-    Okay: a = 1
-    Okay: if a == 0:\n    a = 1
-    E111:   a = 1
-    E114:   # a = 1
-</p><p>
-    Okay: for item in items:\n    pass
-    E112: for item in items:\npass
-    E115: for item in items:\n# Hi\n    pass
-</p><p>
-    Okay: a = 1\nb = 2
-    E113: a = 1\n    b = 2
-    E116: a = 1\n    # b = 2
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="init_checks_registry" ID="init_checks_registry"></a>
-<h2>init_checks_registry</h2>
-<b>init_checks_registry</b>(<i></i>)
-<p>
-Register all globally visible functions.
-</p><p>
-    The first argument name is either 'physical_line' or 'logical_line'.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="is_binary_operator" ID="is_binary_operator"></a>
-<h2>is_binary_operator</h2>
-<b>is_binary_operator</b>(<i>token_type, text</i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="is_string_literal" ID="is_string_literal"></a>
-<h2>is_string_literal</h2>
-<b>is_string_literal</b>(<i>line</i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="maximum_line_length" ID="maximum_line_length"></a>
-<h2>maximum_line_length</h2>
-<b>maximum_line_length</b>(<i>physical_line, max_line_length, multiline</i>)
-<p>
-Limit all lines to a maximum of 79 characters.
-</p><p>
-    There are still many devices around that are limited to 80 character
-    lines; plus, limiting windows to 80 characters makes it possible to have
-    several windows side-by-side.  The default wrapping on such devices looks
-    ugly.  Therefore, please limit all lines to a maximum of 79 characters.
-    For flowing long blocks of text (docstrings or comments), limiting the
-    length to 72 characters is recommended.
-</p><p>
-    Reports error E501.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="missing_whitespace" ID="missing_whitespace"></a>
-<h2>missing_whitespace</h2>
-<b>missing_whitespace</b>(<i>logical_line</i>)
-<p>
-Each comma, semicolon or colon should be followed by whitespace.
-</p><p>
-    Okay: [a, b]
-    Okay: (3,)
-    Okay: a[1:4]
-    Okay: a[:4]
-    Okay: a[1:]
-    Okay: a[1:4:2]
-    E231: ['a','b']
-    E231: foo(bar,baz)
-    E231: [{'a':'b'}]
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="missing_whitespace_around_operator" ID="missing_whitespace_around_operator"></a>
-<h2>missing_whitespace_around_operator</h2>
-<b>missing_whitespace_around_operator</b>(<i>logical_line, tokens</i>)
-<p>
-Surround operators with a single space on either side.
-</p><p>
-    - Always surround these binary operators with a single space on
-      either side: assignment (=), augmented assignment (+=, -= etc.),
-      comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
-      Booleans (and, or, not).
-</p><p>
-    - If operators with different priorities are used, consider adding
-      whitespace around the operators with the lowest priorities.
-</p><p>
-    Okay: i = i + 1
-    Okay: submitted += 1
-    Okay: x = x * 2 - 1
-    Okay: hypot2 = x * x + y * y
-    Okay: c = (a + b) * (a - b)
-    Okay: foo(bar, key='word', *args, **kwargs)
-    Okay: alpha[:-i]
-</p><p>
-    E225: i=i+1
-    E225: submitted +=1
-    E225: x = x /2 - 1
-    E225: z = x **y
-    E226: c = (a+b) * (a-b)
-    E226: hypot2 = x*x + y*y
-    E227: c = a|b
-    E228: msg = fmt%(errno, errmsg)
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="module_imports_on_top_of_file" ID="module_imports_on_top_of_file"></a>
-<h2>module_imports_on_top_of_file</h2>
-<b>module_imports_on_top_of_file</b>(<i>logical_line, indent_level, checker_state, noqa</i>)
-<p>
-Imports are always put at the top of the file, just after any module
-    comments and docstrings, and before module globals and constants.
-</p><p>
-    Okay: import os
-    Okay: # this is a comment\nimport os
-    Okay: '''this is a module docstring'''\nimport os
-    Okay: r'''this is a module docstring'''\nimport os
-    Okay: try:\n    import x\nexcept:\n    pass\nelse:\n    pass\nimport y
-    Okay: try:\n    import x\nexcept:\n    pass\nfinally:\n    pass\nimport y
-    E402: a=1\nimport os
-    E402: 'One string'\n"Two string"\nimport os
-    E402: a=1\nfrom sys import x
-</p><p>
-    Okay: if x:\n    import os
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="mute_string" ID="mute_string"></a>
-<h2>mute_string</h2>
-<b>mute_string</b>(<i>text</i>)
-<p>
-Replace contents with 'xxx' to prevent syntax matching.
-</p><p>
-    >>> mute_string('"abc"')
-    '"xxx"'
-    >>> mute_string("'''abc'''")
-    "'''xxx'''"
-    >>> mute_string("r'abc'")
-    "r'xxx'"
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="normalize_paths" ID="normalize_paths"></a>
-<h2>normalize_paths</h2>
-<b>normalize_paths</b>(<i>value, parent=os.curdir</i>)
-<p>
-Parse a comma-separated list of paths.
-</p><p>
-    Return a list of absolute paths.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="parse_udiff" ID="parse_udiff"></a>
-<h2>parse_udiff</h2>
-<b>parse_udiff</b>(<i>diff, patterns=None, parent='.'</i>)
-<p>
-Return a dictionary of matching lines.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="process_options" ID="process_options"></a>
-<h2>process_options</h2>
-<b>process_options</b>(<i>arglist=None, parse_argv=False, config_file=None, parser=None</i>)
-<p>
-Process options passed either via arglist or via command line args.
-</p><p>
-    Passing in the ``config_file`` parameter allows other tools, such as flake8
-    to specify their own options to be processed in pep8.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="python_3000_backticks" ID="python_3000_backticks"></a>
-<h2>python_3000_backticks</h2>
-<b>python_3000_backticks</b>(<i>logical_line</i>)
-<p>
-Backticks are removed in Python 3: use repr() instead.
-</p><p>
-    Okay: val = repr(1 + 2)
-    W604: val = `1 + 2`
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="python_3000_has_key" ID="python_3000_has_key"></a>
-<h2>python_3000_has_key</h2>
-<b>python_3000_has_key</b>(<i>logical_line, noqa</i>)
-<p>
-The {}.has_key() method is removed in Python 3: use the 'in' operator.
-</p><p>
-    Okay: if "alph" in d:\n    print d["alph"]
-    W601: assert d.has_key('alph')
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="python_3000_not_equal" ID="python_3000_not_equal"></a>
-<h2>python_3000_not_equal</h2>
-<b>python_3000_not_equal</b>(<i>logical_line</i>)
-<p>
-New code should always use != instead of <>.
-</p><p>
-    The older syntax is removed in Python 3.
-</p><p>
-    Okay: if a != 'no':
-    W603: if a <> 'no':
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="python_3000_raise_comma" ID="python_3000_raise_comma"></a>
-<h2>python_3000_raise_comma</h2>
-<b>python_3000_raise_comma</b>(<i>logical_line</i>)
-<p>
-When raising an exception, use "raise ValueError('message')".
-</p><p>
-    The older form is removed in Python 3.
-</p><p>
-    Okay: raise DummyError("Message")
-    W602: raise DummyError, "Message"
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="read_config" ID="read_config"></a>
-<h2>read_config</h2>
-<b>read_config</b>(<i>options, args, arglist, parser</i>)
-<p>
-Read and parse configurations
-</p><p>
-    If a config file is specified on the command line with the "--config"
-    option, then only it is used for configuration.
-</p><p>
-    Otherwise, the user configuration (~/.config/pep8) and any local
-    configurations in the current directory or above will be merged together
-    (in that order) using the read method of ConfigParser.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="readlines" ID="readlines"></a>
-<h2>readlines</h2>
-<b>readlines</b>(<i>filename</i>)
-<p>
-Read the source code.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="readlines_1" ID="readlines_1"></a>
-<h2>readlines</h2>
-<b>readlines</b>(<i>filename</i>)
-<p>
-Read the source code.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="register_check" ID="register_check"></a>
-<h2>register_check</h2>
-<b>register_check</b>(<i>check, codes=None</i>)
-<p>
-Register a new check object.
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="stdin_get_value" ID="stdin_get_value"></a>
-<h2>stdin_get_value</h2>
-<b>stdin_get_value</b>(<i></i>)
-
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="tabs_obsolete" ID="tabs_obsolete"></a>
-<h2>tabs_obsolete</h2>
-<b>tabs_obsolete</b>(<i>physical_line</i>)
-<p>
-For new projects, spaces-only are strongly recommended over tabs.
-</p><p>
-    Okay: if True:\n    return
-    W191: if True:\n\treturn
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="tabs_or_spaces" ID="tabs_or_spaces"></a>
-<h2>tabs_or_spaces</h2>
-<b>tabs_or_spaces</b>(<i>physical_line, indent_char</i>)
-<p>
-Never mix tabs and spaces.
-</p><p>
-    The most popular way of indenting Python is with spaces only.  The
-    second-most popular way is with tabs only.  Code indented with a mixture
-    of tabs and spaces should be converted to using spaces exclusively.  When
-    invoking the Python command line interpreter with the -t option, it issues
-    warnings about code that illegally mixes tabs and spaces.  When using -tt
-    these warnings become errors.  These options are highly recommended!
-</p><p>
-    Okay: if a == 0:\n        a = 1\n        b = 1
-    E101: if a == 0:\n        a = 1\n\tb = 1
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="trailing_blank_lines" ID="trailing_blank_lines"></a>
-<h2>trailing_blank_lines</h2>
-<b>trailing_blank_lines</b>(<i>physical_line, lines, line_number, total_lines</i>)
-<p>
-Trailing blank lines are superfluous.
-</p><p>
-    Okay: spam(1)
-    W391: spam(1)\n
-</p><p>
-    However the last line should end with a new line (warning W292).
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="trailing_whitespace" ID="trailing_whitespace"></a>
-<h2>trailing_whitespace</h2>
-<b>trailing_whitespace</b>(<i>physical_line</i>)
-<p>
-Trailing whitespace is superfluous.
-</p><p>
-    The warning returned varies on whether the line itself is blank, for easier
-    filtering for those who want to indent their blank lines.
-</p><p>
-    Okay: spam(1)\n#
-    W291: spam(1) \n#
-    W293: class Foo(object):\n    \n    bang = 12
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="whitespace_around_comma" ID="whitespace_around_comma"></a>
-<h2>whitespace_around_comma</h2>
-<b>whitespace_around_comma</b>(<i>logical_line</i>)
-<p>
-Avoid extraneous whitespace after a comma or a colon.
-</p><p>
-    Note: these checks are disabled by default
-</p><p>
-    Okay: a = (1, 2)
-    E241: a = (1,  2)
-    E242: a = (1,\t2)
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="whitespace_around_keywords" ID="whitespace_around_keywords"></a>
-<h2>whitespace_around_keywords</h2>
-<b>whitespace_around_keywords</b>(<i>logical_line</i>)
-<p>
-Avoid extraneous whitespace around keywords.
-</p><p>
-    Okay: True and False
-    E271: True and  False
-    E272: True  and False
-    E273: True and\tFalse
-    E274: True\tand False
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="whitespace_around_named_parameter_equals" ID="whitespace_around_named_parameter_equals"></a>
-<h2>whitespace_around_named_parameter_equals</h2>
-<b>whitespace_around_named_parameter_equals</b>(<i>logical_line, tokens</i>)
-<p>
-Don't use spaces around the '=' sign in function arguments.
-</p><p>
-    Don't use spaces around the '=' sign when used to indicate a
-    keyword argument or a default parameter value.
-</p><p>
-    Okay: def complex(real, imag=0.0):
-    Okay: return magic(r=real, i=imag)
-    Okay: boolean(a == b)
-    Okay: boolean(a != b)
-    Okay: boolean(a <= b)
-    Okay: boolean(a >= b)
-    Okay: def foo(arg: int = 42):
-</p><p>
-    E251: def complex(real, imag = 0.0):
-    E251: return magic(r = real, i = imag)
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="whitespace_around_operator" ID="whitespace_around_operator"></a>
-<h2>whitespace_around_operator</h2>
-<b>whitespace_around_operator</b>(<i>logical_line</i>)
-<p>
-Avoid extraneous whitespace around an operator.
-</p><p>
-    Okay: a = 12 + 3
-    E221: a = 4  + 5
-    E222: a = 4 +  5
-    E223: a = 4\t+ 5
-    E224: a = 4 +\t5
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="whitespace_before_comment" ID="whitespace_before_comment"></a>
-<h2>whitespace_before_comment</h2>
-<b>whitespace_before_comment</b>(<i>logical_line, tokens</i>)
-<p>
-Separate inline comments by at least two spaces.
-</p><p>
-    An inline comment is a comment on the same line as a statement.  Inline
-    comments should be separated by at least two spaces from the statement.
-    They should start with a # and a single space.
-</p><p>
-    Each line of a block comment starts with a # and a single space
-    (unless it is indented text inside the comment).
-</p><p>
-    Okay: x = x + 1  # Increment x
-    Okay: x = x + 1    # Increment x
-    Okay: # Block comment
-    E261: x = x + 1 # Increment x
-    E262: x = x + 1  #Increment x
-    E262: x = x + 1  #  Increment x
-    E265: #Block comment
-    E266: ### Block comment
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="whitespace_before_parameters" ID="whitespace_before_parameters"></a>
-<h2>whitespace_before_parameters</h2>
-<b>whitespace_before_parameters</b>(<i>logical_line, tokens</i>)
-<p>
-Avoid extraneous whitespace.
-</p><p>
-    Avoid extraneous whitespace in the following situations:
-    - before the open parenthesis that starts the argument list of a
-      function call.
-    - before the open parenthesis that starts an indexing or slicing.
-</p><p>
-    Okay: spam(1)
-    E211: spam (1)
-</p><p>
-    Okay: dict['key'] = list[index]
-    E211: dict ['key'] = list[index]
-    E211: dict['key'] = list [index]
-</p>
-<div align="right"><a href="#top">Up</a></div>
-<hr />
-</body></html>
\ No newline at end of file
--- a/Plugins/CheckerPlugins/CodeStyleChecker/pep8.py	Sun Sep 04 14:34:56 2016 +0200
+++ b/Plugins/CheckerPlugins/CodeStyleChecker/pep8.py	Sun Sep 04 16:50:23 2016 +0200
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-# pep8.py - Check Python source code formatting, according to PEP 8
+# pycodestyle.py - Check Python source code formatting, according to PEP 8
 # Copyright (C) 2006-2009 Johann C. Rocholl <johann@rocholl.net>
 # Copyright (C) 2009-2014 Florent Xicluna <florent.xicluna@gmail.com>
 # Copyright (C) 2014-2016 Ian Lee <ianlee1521@gmail.com>
@@ -30,10 +30,10 @@
 Check Python source code formatting, according to PEP 8.
 
 For usage and a list of options, try this:
-$ python pep8.py -h
+$ python pycodestyle.py -h
 
 This program and its regression test suite live here:
-https://github.com/pycqa/pep8
+https://github.com/pycqa/pycodestyle
 
 Groups of errors and warnings:
 E errors
@@ -60,38 +60,38 @@
 # Copyright (c) 2011 - 2016 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 
-import os
-import sys
-import re
-import time
 import inspect
 import keyword
+import os
+import re
+import sys
+import time
 import tokenize
-import ast
+##import ast
+from fnmatch import fnmatch
 from optparse import OptionParser
-from fnmatch import fnmatch
 try:
     from configparser import RawConfigParser
     from io import TextIOWrapper
 except ImportError:
     from ConfigParser import RawConfigParser            # __IGNORE_WARNING__
 
-__version__ = '1.7.0'
+__version__ = '2.1.0.dev0'
 
 DEFAULT_EXCLUDE = '.svn,CVS,.bzr,.hg,.git,__pycache__,.tox'
-DEFAULT_IGNORE = 'E121,E123,E126,E226,E24,E704'
+DEFAULT_IGNORE = 'E121,E123,E126,E226,E24,E704,W503'
 try:
     if sys.platform == 'win32':
-        USER_CONFIG = os.path.expanduser(r'~\.pep8')
+        USER_CONFIG = os.path.expanduser(r'~\.pycodestyle')
     else:
         USER_CONFIG = os.path.join(
             os.getenv('XDG_CONFIG_HOME') or os.path.expanduser('~/.config'),
-            'pep8'
+            'pycodestyle'
         )
 except ImportError:
     USER_CONFIG = None
 
-PROJECT_CONFIG = ('setup.cfg', 'tox.ini', '.pep8')
+PROJECT_CONFIG = ('setup.cfg', 'tox.ini')
 TESTSUITE_PATH = os.path.join(os.path.dirname(__file__), 'testsuite')
 MAX_LINE_LENGTH = 79
 REPORT_FORMAT = {
@@ -99,6 +99,7 @@
     'pylint': '%(path)s:%(row)d: [%(code)s] %(text)s',
 }
 
+PyCF_ONLY_AST = 1024
 SINGLETONS = frozenset(['False', 'None', 'True'])
 KEYWORDS = frozenset(keyword.kwlist + ['print']) - SINGLETONS
 UNARY_OPERATORS = frozenset(['>>', '**', '*', '+', '-'])
@@ -208,7 +209,7 @@
             return len(physical_line), "W292 no newline at end of file"
 
 
-def maximum_line_length(physical_line, max_line_length, multiline):
+def maximum_line_length(physical_line, max_line_length, multiline, noqa):
     r"""Limit all lines to a maximum of 79 characters.
 
     There are still many devices around that are limited to 80 character
@@ -222,7 +223,7 @@
     """
     line = physical_line.rstrip()
     length = len(line)
-    if length > max_line_length and not noqa(line):
+    if length > max_line_length and not noqa:
         # Special case for long URLs in multi-line docstrings or comments,
         # but still report the error when the 72 first chars are whitespaces.
         chunks = line.split()
@@ -248,7 +249,9 @@
 
 
 def blank_lines(logical_line, blank_lines, indent_level, line_number,
-                blank_before, previous_logical, previous_indent_level):
+                blank_before, previous_logical,
+                previous_unindented_logical_line, previous_indent_level,
+                lines):
     r"""Separate top-level function and class definitions with two blank lines.
 
     Method definitions inside a class are separated by a single blank line.
@@ -260,13 +263,16 @@
     Use blank lines in functions, sparingly, to indicate logical sections.
 
     Okay: def a():\n    pass\n\n\ndef b():\n    pass
+    Okay: def a():\n    pass\n\n\nasync def b():\n    pass
     Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
 
     E301: class Foo:\n    b = 0\n    def bar():\n        pass
     E302: def a():\n    pass\n\ndef b(n):\n    pass
+    E302: def a():\n    pass\n\nasync def b(n):\n    pass
     E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
     E303: def a():\n\n\n\n    pass
     E304: @decorator\n\ndef a():\n    pass
+    E305: def a():\n    pass\na()
     """
     if line_number < 3 and not previous_logical:
         return  # Don't expect blank lines before the first line
@@ -275,13 +281,30 @@
             yield 0, "E304 blank lines found after function decorator"
     elif blank_lines > 2 or (indent_level and blank_lines == 2):
         yield 0, "E303 too many blank lines (%d)", blank_lines
-    elif logical_line.startswith(('def ', 'class ', '@')):
+    elif logical_line.startswith(('def ', 'async def ', 'class ', '@')):
         if indent_level:
             if not (blank_before or previous_indent_level < indent_level or
                     DOCSTRING_REGEX.match(previous_logical)):
-                yield 0, "E301 expected 1 blank line, found 0"
+                ancestor_level = indent_level
+                nested = False
+                # Search backwards for a def ancestor or tree root (top level).
+                for line in lines[line_number - 2::-1]:
+                    if line.strip() and expand_indent(line) < ancestor_level:
+                        ancestor_level = expand_indent(line)
+                        nested = line.lstrip().startswith('def ')
+                        if nested or ancestor_level == 0:
+                            break
+                if nested:
+                    yield 0, "E306 expected 1 blank line before a " \
+                        "nested definition, found 0"
+                else:
+                    yield 0, "E301 expected 1 blank line, found 0"
         elif blank_before != 2:
             yield 0, "E302 expected 2 blank lines, found %d", blank_before
+    elif (logical_line and not indent_level and blank_before != 2 and
+          previous_unindented_logical_line.startswith(('def', 'class'))):
+        yield 0, "E305 expected 2 blank lines after " \
+            "class or function definition, found %d", blank_before
 
 
 def extraneous_whitespace(logical_line):
@@ -339,6 +362,23 @@
             yield match.start(2), "E271 multiple spaces after keyword"
 
 
+def missing_whitespace_after_import_keyword(logical_line):
+    r"""Multiple imports in form from x import (a, b, c) should have space
+    between import statement and parenthesised name list.
+
+    Okay: from foo import (bar, baz)
+    E275: from foo import(bar, baz)
+    E275: from importable.module import(bar, baz)
+    """
+    line = logical_line
+    indicator = ' import('
+    if line.startswith('from '):
+        found = line.find(indicator)
+        if -1 < found:
+            pos = found + len(indicator) - 1
+            yield pos, "E275 missing whitespace after keyword"
+
+
 def missing_whitespace(logical_line):
     r"""Each comma, semicolon or colon should be followed by whitespace.
 
@@ -579,7 +619,7 @@
                         break
             assert len(indent) == depth + 1
             if start[1] not in indent_chances:
-                # allow to line up tokens
+                # allow lining up tokens
                 indent_chances[start[1]] = text
 
         last_token_multiline = (start[0] != end[0])
@@ -773,6 +813,7 @@
     Okay: boolean(a <= b)
     Okay: boolean(a >= b)
     Okay: def foo(arg: int = 42):
+    Okay: async def foo(arg: int = 42):
 
     E251: def complex(real, imag = 0.0):
     E251: return magic(r = real, i = imag)
@@ -781,7 +822,7 @@
     no_space = False
     prev_end = None
     annotated_func_arg = False
-    in_def = logical_line.startswith('def')
+    in_def = logical_line.startswith(('def', 'async def'))
     message = "E251 unexpected spaces around keyword / parameter equals"
     for token_type, text, start, end, line in tokens:
         if token_type == tokenize.NL:
@@ -791,9 +832,9 @@
             if start != prev_end:
                 yield (prev_end, message)
         if token_type == tokenize.OP:
-            if text == '(':
+            if text in '([':
                 parens += 1
-            elif text == ')':
+            elif text in ')]':
                 parens -= 1
             elif in_def and text == ':' and parens == 1:
                 annotated_func_arg = True
@@ -851,7 +892,7 @@
 
 
 def imports_on_separate_lines(logical_line):
-    r"""Imports should usually be on separate lines.
+    r"""Place imports on separate lines.
 
     Okay: import os\nimport sys
     E401: import sys, os
@@ -871,8 +912,10 @@
 
 def module_imports_on_top_of_file(
         logical_line, indent_level, checker_state, noqa):
-    r"""Imports are always put at the top of the file, just after any module
-    comments and docstrings, and before module globals and constants.
+    r"""Place imports at the top of the file.
+
+    Always put imports at the top of the file, just after any module comments
+    and docstrings, and before module globals and constants.
 
     Okay: import os
     Okay: # this is a comment\nimport os
@@ -945,27 +988,33 @@
     E702: do_one(); do_two(); do_three()
     E703: do_four();  # useless semicolon
     E704: def f(x): return 2*x
+    E705: async def f(x): return 2*x
     E731: f = lambda x: 2*x
     """
     line = logical_line
     last_char = len(line) - 1
     found = line.find(':')
+    prev_found = 0
+    counts = dict((char, 0) for char in '{}[]()')
     while -1 < found < last_char:
-        before = line[:found]
-        if ((before.count('{') <= before.count('}') and   # {'a': 1} (dict)
-             before.count('[') <= before.count(']') and   # [1:2] (slice)
-             before.count('(') <= before.count(')'))):    # (annotation)
-            lambda_kw = LAMBDA_REGEX.search(before)
+        update_counts(line[prev_found:found], counts)
+        if ((counts['{'] <= counts['}'] and   # {'a': 1} (dict)
+             counts['['] <= counts[']'] and   # [1:2] (slice)
+             counts['('] <= counts[')'])):    # (annotation)
+            lambda_kw = LAMBDA_REGEX.search(line, 0, found)
             if lambda_kw:
                 before = line[:lambda_kw.start()].rstrip()
                 if before[-1:] == '=' and isidentifier(before[:-1].strip()):
                     yield 0, ("E731 do not assign a lambda expression, use a "
                               "def")
                 break
-            if before.startswith('def '):
+            if line.startswith('def '):
                 yield 0, "E704 multiple statements on one line (def)"
+            elif line.startswith('async def '):
+                yield 0, "E705 multiple statements on one line (async def)"
             else:
                 yield found, "E701 multiple statements on one line (colon)"
+        prev_found = found
         found = line.find(':', found + 1)
     found = line.find(';')
     while -1 < found:
@@ -1031,16 +1080,22 @@
     Okay: x = '''\n''' + ''
     Okay: foo(x,\n    -y)
     Okay: foo(x,  # comment\n    -y)
+    Okay: var = (1 &\n       ~2)
+    Okay: var = (1 /\n       -2)
+    Okay: var = (1 +\n       -1 +\n       -2)
     """
     def is_binary_operator(token_type, text):
         # The % character is strictly speaking a binary operator, but the
         # common usage seems to be to put it next to the format parameters,
         # after a line break.
         return ((token_type == tokenize.OP or text in ['and', 'or']) and
-                text not in "()[]{},:.;@=%")
+                text not in "()[]{},:.;@=%~")
 
     line_break = False
     unary_context = True
+    # Previous non-newline token types and text
+    previous_token_type = None
+    previous_text = None
     for token_type, text, start, end, line in tokens:
         if token_type == tokenize.COMMENT:
             continue
@@ -1048,10 +1103,14 @@
             line_break = True
         else:
             if (is_binary_operator(token_type, text) and line_break and
-                    not unary_context):
+                    not unary_context and
+                    not is_binary_operator(previous_token_type,
+                                           previous_text)):
                 yield start, "W503 line break before binary operator"
             unary_context = text in '([{,;'
             line_break = False
+            previous_token_type = token_type
+            previous_text = text
 
 
 def comparison_to_singleton(logical_line, noqa):
@@ -1084,8 +1143,8 @@
             nonzero = ((singleton == 'True' and same) or
                        (singleton == 'False' and not same))
             msg += " or 'if %scond:'" % ('' if nonzero else 'not ')
-        yield (match.start(2), "%s comparison to %s should be %s" %
-                               (code, singleton, msg), singleton, msg)
+        yield (match.start(2), ("%s comparison to %s should be %s" %
+                                (code, singleton, msg)), singleton, msg)
 
 
 def comparison_negative(logical_line):
@@ -1132,6 +1191,58 @@
         yield match.start(), "E721 do not compare types, use 'isinstance()'"
 
 
+def ambiguous_identifier(logical_line, tokens):
+    r"""Never use the characters 'l', 'O', or 'I' as variable names.
+
+    In some fonts, these characters are indistinguishable from the numerals
+    one and zero. When tempted to use 'l', use 'L' instead.
+
+    Okay: L = 0
+    Okay: o = 123
+    Okay: i = 42
+    E741: l = 0
+    E741: O = 123
+    E741: I = 42
+
+    Variables can be bound in several other contexts, including class and
+    function definitions, 'global' and 'nonlocal' statements, exception
+    handlers, and 'with' statements.
+
+    Okay: except AttributeError as o:
+    Okay: with lock as L:
+    E741: except AttributeError as O:
+    E741: with lock as l:
+    E741: global I
+    E741: nonlocal l
+    E742: class I(object):
+    E743: def l(x):
+    """
+    idents_to_avoid = ('l', 'O', 'I')
+    prev_type, prev_text, prev_start, prev_end, __ = tokens[0]
+    for token_type, text, start, end, line in tokens[1:]:
+        ident = pos = None
+        # identifiers on the lhs of an assignment operator
+        if token_type == tokenize.OP and '=' in text:
+            if prev_text in idents_to_avoid:
+                ident = prev_text
+                pos = prev_start
+        # identifiers bound to a value with 'as', 'global', or 'nonlocal'
+        if prev_text in ('as', 'global', 'nonlocal'):
+            if text in idents_to_avoid:
+                ident = text
+                pos = start
+        if prev_text == 'class':
+            if text in idents_to_avoid:
+                yield start, "E742 ambiguous class definition '%s'", text
+        if prev_text == 'def':
+            if text in idents_to_avoid:
+                yield start, "E743 ambiguous function definition '%s'", text
+        if ident:
+            yield pos, "E741 ambiguous variable name '%s'", ident
+        prev_text = text
+        prev_start = start
+
+
 def python_3000_has_key(logical_line, noqa):
     r"""The {}.has_key() method is removed in Python 3: use the 'in' operator.
 
@@ -1170,7 +1281,7 @@
 
 
 def python_3000_backticks(logical_line):
-    r"""Backticks are removed in Python 3: use repr() instead.
+    r"""Use repr() instead of backticks in Python 3.
 
     Okay: val = repr(1 + 2)
     W604: val = `1 + 2`
@@ -1201,7 +1312,7 @@
             with open(filename, 'rb') as f:
                 (coding, lines) = tokenize.detect_encoding(f.readline)
                 f = TextIOWrapper(f, coding, line_buffering=True)
-                return [l.decode(coding) for l in lines] + f.readlines()
+                return [line.decode(coding) for line in lines] + f.readlines()
         except (LookupError, SyntaxError, UnicodeError):
             # Fall back if file encoding is improperly declared
             with open(filename, encoding='latin-1') as f:
@@ -1209,7 +1320,9 @@
     isidentifier = str.isidentifier
 
     def stdin_get_value():
+        """Read the value from stdin."""
         return TextIOWrapper(sys.stdin.buffer, errors='ignore').read()
+
 noqa = re.compile(r'# no(?:qa|pep8)\b', re.I).search
 
 
@@ -1313,8 +1426,18 @@
     return any(fnmatch(filename, pattern) for pattern in patterns)
 
 
+def update_counts(s, counts):
+    r"""Adds one to the counts of each appearance of characters in s,
+        for characters in counts"""
+    for char in s:
+        if char in counts:
+            counts[char] += 1
+
+
 def _is_eol_token(token):
     return token[0] in NEWLINE or token[4][token[3][1]:].lstrip() == '\\\n'
+
+
 if COMMENT_WITH_NL:
     def _is_eol_token(token, _eol_token=_is_eol_token):
         return _eol_token(token) or (token[0] == tokenize.COMMENT and
@@ -1364,6 +1487,8 @@
     mod = inspect.getmodule(register_check)
     for (name, function) in inspect.getmembers(mod, inspect.isfunction):
         register_check(function)
+
+
 init_checks_registry()
 
 
@@ -1412,6 +1537,7 @@
         self.report = report or options.report
         self.report_error = self.report.error
         self.report_error_args = self.report.error_args
+        self.noqa = False
         
         # added for eric6 integration
         self.options = options
@@ -1447,7 +1573,7 @@
         return check(*arguments)
 
     def init_checker_state(self, name, argument_names):
-        """ Prepares a custom state for the specific checker plugin."""
+        """ Prepare custom state for the specific checker plugin."""
         if 'checker_state' in argument_names:
             self.checker_state = self._checker_states.setdefault(name, {})
 
@@ -1530,13 +1656,15 @@
         if self.logical_line:
             self.previous_indent_level = self.indent_level
             self.previous_logical = self.logical_line
+            if not self.indent_level:
+                self.previous_unindented_logical_line = self.logical_line
         self.blank_lines = 0
         self.tokens = []
 
     def check_ast(self):
         """Build the file's AST and run all AST checks."""
         try:
-            tree = compile(''.join(self.lines), '', 'exec', ast.PyCF_ONLY_AST)
+            tree = compile(''.join(self.lines), '', 'exec', PyCF_ONLY_AST)
         except (ValueError, SyntaxError, TypeError):
             return self.report_invalid_syntax()
         for name, cls, __ in self._ast_checks:
@@ -1556,6 +1684,7 @@
             for token in tokengen:
                 if token[2][0] > self.total_lines:
                     return
+                self.noqa = token[4] and noqa(token[4])
                 self.maybe_check_physical(token)
                 yield token
         except (SyntaxError, tokenize.TokenError):
@@ -1601,6 +1730,7 @@
         self.indent_char = None
         self.indent_level = self.previous_indent_level = 0
         self.previous_logical = ''
+        self.previous_unindented_logical_line = ''
         self.tokens = []
         self.blank_lines = self.blank_before = 0
         parens = 0
@@ -1866,7 +1996,8 @@
 #            # The default choice: ignore controversial checks
 #            options.ignore = tuple(DEFAULT_IGNORE.split(','))
 #        else:
-        # Ignore all checks which are not explicitly selected or all if no
+#            # Ignore all checks which are not explicitly selected or all if no
+#            options.ignore = ('',) if options.select else tuple(options.ignore)
 
         # check is ignored or explicitly selected
         options.ignore = ('',) if options.select else tuple(options.ignore)
@@ -1972,7 +2103,8 @@
         return sorted(checks)
 
 
-def get_parser(prog='pep8', version=__version__):
+def get_parser(prog='pycodestyle', version=__version__):
+    """Create the parser for the program."""
     parser = OptionParser(prog=prog, version=version,
                           usage="%prog [options] input ...")
     parser.config_options = [
@@ -2039,7 +2171,7 @@
     If a config file is specified on the command line with the "--config"
     option, then only it is used for configuration.
 
-    Otherwise, the user configuration (~/.config/pep8) and any local
+    Otherwise, the user configuration (~/.config/pycodestyle) and any local
     configurations in the current directory or above will be merged together
     (in that order) using the read method of ConfigParser.
     """
@@ -2087,13 +2219,12 @@
             opt_type = option_list[normalized_opt]
             if opt_type in ('int', 'count'):
                 value = config.getint(pep8_section, opt)
-            elif opt_type == 'string':
+            elif opt_type in ('store_true', 'store_false'):
+                value = config.getboolean(pep8_section, opt)
+            else:
                 value = config.get(pep8_section, opt)
                 if normalized_opt == 'exclude':
                     value = normalize_paths(value, local_dir)
-            else:
-                assert opt_type in ('store_true', 'store_false')
-                value = config.getboolean(pep8_section, opt)
             setattr(new_options, normalized_opt, value)
 
         # Third, overwrite with the command-line options
@@ -2107,7 +2238,7 @@
     """Process options passed either via arglist or via command line args.
 
     Passing in the ``config_file`` parameter allows other tools, such as flake8
-    to specify their own options to be processed in pep8.
+    to specify their own options to be processed in pycodestyle.
     """
     if not parser:
         parser = get_parser()
@@ -2179,14 +2310,14 @@
     except AttributeError:
         pass    # not supported on Windows
 
-    pep8style = StyleGuide(parse_argv=True)
-    options = pep8style.options
+    style_guide = StyleGuide(parse_argv=True)
+    options = style_guide.options
 
     if options.doctest or options.testsuite:
         from testsuite.support import run_tests
-        report = run_tests(pep8style)
+        report = run_tests(style_guide)
     else:
-        report = pep8style.check_files()
+        report = style_guide.check_files()
 
     if options.statistics:
         report.print_statistics()
--- a/Plugins/CheckerPlugins/CodeStyleChecker/translations.py	Sun Sep 04 14:34:56 2016 +0200
+++ b/Plugins/CheckerPlugins/CodeStyleChecker/translations.py	Sun Sep 04 16:50:23 2016 +0200
@@ -146,6 +146,9 @@
     "E274": QCoreApplication.translate(
         "pep8",
         "tab before keyword"),
+    "E275": QCoreApplication.translate(
+        "pep8",
+        "missing whitespace after keyword"),
     "W291": QCoreApplication.translate(
         "pep8",
         "trailing whitespace"),
@@ -167,6 +170,13 @@
     "E304": QCoreApplication.translate(
         "pep8",
         "blank lines found after function decorator"),
+    "E305": QCoreApplication.translate(
+        "pep8",
+        "expected 2 blank lines after class or function definition,"
+        " found {0}"),
+    "E306": QCoreApplication.translate(
+        "pep8",
+        "expected 1 blank line before a nested definition, found 0"),
     "W391": QCoreApplication.translate(
         "pep8",
         "blank line at end of file"),
@@ -209,6 +219,9 @@
     "E704": QCoreApplication.translate(
         "pep8",
         "multiple statements on one line (def)"),
+    "E705": QCoreApplication.translate(
+        "pep8",
+        "multiple statements on one line (async def)"),
     "E711": QCoreApplication.translate(
         "pep8",
         "comparison to {0} should be {1}"),
@@ -227,6 +240,15 @@
     "E731": QCoreApplication.translate(
         "pep8",
         "do not assign a lambda expression, use a def"),
+    "E741": QCoreApplication.translate(
+        "pep8",
+        "ambiguous variable name '{0}'"),
+    "E742": QCoreApplication.translate(
+        "pep8",
+        "ambiguous class definition '{0}'"),
+    "E743": QCoreApplication.translate(
+        "pep8",
+        "ambiguous function definition '{0}'"),
     "E901": QCoreApplication.translate(
         "pep8",
         "{0}: {1}"),
@@ -631,9 +653,13 @@
     "E242": [",;:"],
     "E302": [1],
     "E303": [3],
+    "E305": [1],
     "E501": [85, 79],
     "E711": ["None", "'if cond is None:'"],
     "E712": ["True", "'if cond is True:' or 'if cond:'"],
+    "E741": ["l"],
+    "E742": ["l"],
+    "E743": ["l"],
     "E901": ["SyntaxError", "Invalid Syntax"],
     "E902": ["IOError"],
     "D232": ["public"],

eric ide

mercurial