Merge pull request #63 from brenda-br/Fix-35HEADmaster

Restructure Project and Deployment

1 files changed, 0 insertions, 1332 deletions

diff --git a/venv/Lib/site-packages/pylint/checkers/format.py b/venv/Lib/site-packages/pylint/checkers/format.py
deleted file mode 100644
index c4cad31..0000000
--- a/venv/Lib/site-packages/pylint/checkers/format.py
+++ /dev/null
@@ -1,1332 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2006-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
-# Copyright (c) 2012-2015 Google, Inc.
-# Copyright (c) 2013 moxian <aleftmail@inbox.ru>
-# Copyright (c) 2014-2018 Claudiu Popa <pcmanticore@gmail.com>
-# Copyright (c) 2014 frost-nzcr4 <frost.nzcr4@jagmort.com>
-# Copyright (c) 2014 Brett Cannon <brett@python.org>
-# Copyright (c) 2014 Michal Nowikowski <godfryd@gmail.com>
-# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
-# Copyright (c) 2015 Mike Frysinger <vapier@gentoo.org>
-# Copyright (c) 2015 Fabio Natali <me@fabionatali.com>
-# Copyright (c) 2015 Harut <yes@harutune.name>
-# Copyright (c) 2015 Mihai Balint <balint.mihai@gmail.com>
-# Copyright (c) 2015 Pavel Roskin <proski@gnu.org>
-# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
-# Copyright (c) 2016 Petr Pulc <petrpulc@gmail.com>
-# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com>
-# Copyright (c) 2016 Ashley Whetter <ashley@awhetter.co.uk>
-# Copyright (c) 2017-2018 Bryce Guinta <bryce.paul.guinta@gmail.com>
-# Copyright (c) 2017 hippo91 <guillaume.peillex@gmail.com>
-# Copyright (c) 2017 Krzysztof Czapla <k.czapla68@gmail.com>
-# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com>
-# Copyright (c) 2017 James M. Allen <james.m.allen@gmail.com>
-# Copyright (c) 2017 vinnyrose <vinnyrose@users.noreply.github.com>
-# Copyright (c) 2018 Bryce Guinta <bryce.guinta@protonmail.com>
-# Copyright (c) 2018 Mike Frysinger <vapier@gmail.com>
-# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
-# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu>
-# Copyright (c) 2018 Fureigh <rhys.fureigh@gsa.gov>
-# Copyright (c) 2018 Pierre Sassoulas <pierre.sassoulas@wisebim.fr>
-# Copyright (c) 2018 Andreas Freimuth <andreas.freimuth@united-bits.de>
-# Copyright (c) 2018 Jakub Wilk <jwilk@jwilk.net>
-
-# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
-# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
-
-"""Python code format's checker.
-
-By default try to follow Guido's style guide :
-
-https://www.python.org/doc/essays/styleguide/
-
-Some parts of the process_token method is based from The Tab Nanny std module.
-"""
-
-import keyword
-import tokenize
-from functools import reduce  # pylint: disable=redefined-builtin
-
-from astroid import nodes
-
-from pylint.checkers import BaseTokenChecker
-from pylint.checkers.utils import check_messages
-from pylint.constants import OPTION_RGX, WarningScope
-from pylint.interfaces import IAstroidChecker, IRawChecker, ITokenChecker
-
-_ASYNC_TOKEN = "async"
-_CONTINUATION_BLOCK_OPENERS = [
-    "elif",
-    "except",
-    "for",
-    "if",
-    "while",
-    "def",
-    "class",
-    "with",
-]
-_KEYWORD_TOKENS = [
-    "assert",
-    "del",
-    "elif",
-    "except",
-    "for",
-    "if",
-    "in",
-    "not",
-    "raise",
-    "return",
-    "while",
-    "yield",
-    "with",
-]
-
-_SPACED_OPERATORS = [
-    "==",
-    "<",
-    ">",
-    "!=",
-    "<>",
-    "<=",
-    ">=",
-    "+=",
-    "-=",
-    "*=",
-    "**=",
-    "/=",
-    "//=",
-    "&=",
-    "|=",
-    "^=",
-    "%=",
-    ">>=",
-    "<<=",
-]
-_OPENING_BRACKETS = ["(", "[", "{"]
-_CLOSING_BRACKETS = [")", "]", "}"]
-_TAB_LENGTH = 8
-
-_EOL = frozenset([tokenize.NEWLINE, tokenize.NL, tokenize.COMMENT])
-_JUNK_TOKENS = (tokenize.COMMENT, tokenize.NL)
-
-# Whitespace checking policy constants
-_MUST = 0
-_MUST_NOT = 1
-_IGNORE = 2
-
-# Whitespace checking config constants
-_DICT_SEPARATOR = "dict-separator"
-_TRAILING_COMMA = "trailing-comma"
-_EMPTY_LINE = "empty-line"
-_NO_SPACE_CHECK_CHOICES = [_TRAILING_COMMA, _DICT_SEPARATOR, _EMPTY_LINE]
-_DEFAULT_NO_SPACE_CHECK_CHOICES = [_TRAILING_COMMA, _DICT_SEPARATOR]
-
-MSGS = {
-    "C0301": (
-        "Line too long (%s/%s)",
-        "line-too-long",
-        "Used when a line is longer than a given number of characters.",
-    ),
-    "C0302": (
-        "Too many lines in module (%s/%s)",  # was W0302
-        "too-many-lines",
-        "Used when a module has too many lines, reducing its readability.",
-    ),
-    "C0303": (
-        "Trailing whitespace",
-        "trailing-whitespace",
-        "Used when there is whitespace between the end of a line and the newline.",
-    ),
-    "C0304": (
-        "Final newline missing",
-        "missing-final-newline",
-        "Used when the last line in a file is missing a newline.",
-    ),
-    "C0305": (
-        "Trailing newlines",
-        "trailing-newlines",
-        "Used when there are trailing blank lines in a file.",
-    ),
-    "W0311": (
-        "Bad indentation. Found %s %s, expected %s",
-        "bad-indentation",
-        "Used when an unexpected number of indentation's tabulations or "
-        "spaces has been found.",
-    ),
-    "C0330": ("Wrong %s indentation%s%s.\n%s%s", "bad-continuation", "TODO"),
-    "W0312": (
-        "Found indentation with %ss instead of %ss",
-        "mixed-indentation",
-        "Used when there are some mixed tabs and spaces in a module.",
-    ),
-    "W0301": (
-        "Unnecessary semicolon",  # was W0106
-        "unnecessary-semicolon",
-        'Used when a statement is ended by a semi-colon (";"), which '
-        "isn't necessary (that's python, not C ;).",
-    ),
-    "C0321": (
-        "More than one statement on a single line",
-        "multiple-statements",
-        "Used when more than on statement are found on the same line.",
-        {"scope": WarningScope.NODE},
-    ),
-    "C0325": (
-        "Unnecessary parens after %r keyword",
-        "superfluous-parens",
-        "Used when a single item in parentheses follows an if, for, or "
-        "other keyword.",
-    ),
-    "C0326": (
-        "%s space %s %s %s\n%s",
-        "bad-whitespace",
-        (
-            "Used when a wrong number of spaces is used around an operator, "
-            "bracket or block opener."
-        ),
-        {
-            "old_names": [
-                ("C0323", "no-space-after-operator"),
-                ("C0324", "no-space-after-comma"),
-                ("C0322", "no-space-before-operator"),
-            ]
-        },
-    ),
-    "C0327": (
-        "Mixed line endings LF and CRLF",
-        "mixed-line-endings",
-        "Used when there are mixed (LF and CRLF) newline signs in a file.",
-    ),
-    "C0328": (
-        "Unexpected line ending format. There is '%s' while it should be '%s'.",
-        "unexpected-line-ending-format",
-        "Used when there is different newline than expected.",
-    ),
-}
-
-
-def _underline_token(token):
-    length = token[3][1] - token[2][1]
-    offset = token[2][1]
-    referenced_line = token[4]
-    # If the referenced line does not end with a newline char, fix it
-    if referenced_line[-1] != "\n":
-        referenced_line += "\n"
-    return referenced_line + (" " * offset) + ("^" * length)
-
-
-def _column_distance(token1, token2):
-    if token1 == token2:
-        return 0
-    if token2[3] < token1[3]:
-        token1, token2 = token2, token1
-    if token1[3][0] != token2[2][0]:
-        return None
-    return token2[2][1] - token1[3][1]
-
-
-def _last_token_on_line_is(tokens, line_end, token):
-    return (
-        line_end > 0
-        and tokens.token(line_end - 1) == token
-        or line_end > 1
-        and tokens.token(line_end - 2) == token
-        and tokens.type(line_end - 1) == tokenize.COMMENT
-    )
-
-
-def _token_followed_by_eol(tokens, position):
-    return (
-        tokens.type(position + 1) == tokenize.NL
-        or tokens.type(position + 1) == tokenize.COMMENT
-        and tokens.type(position + 2) == tokenize.NL
-    )
-
-
-def _get_indent_string(line):
-    """Return the indention string of the given line."""
-    result = ""
-    for char in line:
-        if char in " \t":
-            result += char
-        else:
-            break
-    return result
-
-
-def _get_indent_length(line):
-    """Return the length of the indentation on the given token's line."""
-    result = 0
-    for char in line:
-        if char == " ":
-            result += 1
-        elif char == "\t":
-            result += _TAB_LENGTH
-        else:
-            break
-    return result
-
-
-def _get_indent_hint_line(bar_positions, bad_position):
-    """Return a line with |s for each of the positions in the given lists."""
-    if not bar_positions:
-        return "", ""
-
-    bar_positions = [_get_indent_length(indent) for indent in bar_positions]
-    bad_position = _get_indent_length(bad_position)
-    delta_message = ""
-    markers = [(pos, "|") for pos in bar_positions]
-    if len(markers) == 1:
-        # if we have only one marker we'll provide an extra hint on how to fix
-        expected_position = markers[0][0]
-        delta = abs(expected_position - bad_position)
-        direction = "add" if expected_position > bad_position else "remove"
-        delta_message = _CONTINUATION_HINT_MESSAGE % (
-            direction,
-            delta,
-            "s" if delta > 1 else "",
-        )
-    markers.append((bad_position, "^"))
-    markers.sort()
-    line = [" "] * (markers[-1][0] + 1)
-    for position, marker in markers:
-        line[position] = marker
-    return "".join(line), delta_message
-
-
-class _ContinuedIndent:
-    __slots__ = (
-        "valid_outdent_strings",
-        "valid_continuation_strings",
-        "context_type",
-        "token",
-        "position",
-    )
-
-    def __init__(
-        self,
-        context_type,
-        token,
-        position,
-        valid_outdent_strings,
-        valid_continuation_strings,
-    ):
-        self.valid_outdent_strings = valid_outdent_strings
-        self.valid_continuation_strings = valid_continuation_strings
-        self.context_type = context_type
-        self.position = position
-        self.token = token
-
-
-# The contexts for hanging indents.
-# A hanging indented dictionary value after :
-HANGING_DICT_VALUE = "dict-value"
-# Hanging indentation in an expression.
-HANGING = "hanging"
-# Hanging indentation in a block header.
-HANGING_BLOCK = "hanging-block"
-# Continued indentation inside an expression.
-CONTINUED = "continued"
-# Continued indentation in a block header.
-CONTINUED_BLOCK = "continued-block"
-
-SINGLE_LINE = "single"
-WITH_BODY = "multi"
-
-_CONTINUATION_MSG_PARTS = {
-    HANGING_DICT_VALUE: ("hanging", " in dict value"),
-    HANGING: ("hanging", ""),
-    HANGING_BLOCK: ("hanging", " before block"),
-    CONTINUED: ("continued", ""),
-    CONTINUED_BLOCK: ("continued", " before block"),
-}
-
-_CONTINUATION_HINT_MESSAGE = " (%s %d space%s)"  # Ex: (remove 2 spaces)
-
-
-def _Indentations(*args):
-    """Valid indentation strings for a continued line."""
-    return {a: None for a in args}
-
-
-def _BeforeBlockIndentations(single, with_body):
-    """Valid alternative indentation strings for continued lines before blocks.
-
-    :param int single: Valid indentation string for statements on a single logical line.
-    :param int with_body: Valid indentation string for statements on several lines.
-
-    :returns: A dictionary mapping indent offsets to a string representing
-        whether the indent if for a line or block.
-    :rtype: dict
-    """
-    return {single: SINGLE_LINE, with_body: WITH_BODY}
-
-
-class TokenWrapper:
-    """A wrapper for readable access to token information."""
-
-    def __init__(self, tokens):
-        self._tokens = tokens
-
-    def token(self, idx):
-        return self._tokens[idx][1]
-
-    def type(self, idx):
-        return self._tokens[idx][0]
-
-    def start_line(self, idx):
-        return self._tokens[idx][2][0]
-
-    def start_col(self, idx):
-        return self._tokens[idx][2][1]
-
-    def line(self, idx):
-        return self._tokens[idx][4]
-
-    def line_indent(self, idx):
-        """Get the string of TABs and Spaces used for indentation of the line of this token"""
-        return _get_indent_string(self.line(idx))
-
-    def token_indent(self, idx):
-        """Get an indentation string for hanging indentation, consisting of the line-indent plus
-        a number of spaces to fill up to the column of this token.
-
-        e.g. the token indent for foo
-        in "<TAB><TAB>print(foo)"
-        is "<TAB><TAB>      "
-        """
-        line_indent = self.line_indent(idx)
-        return line_indent + " " * (self.start_col(idx) - len(line_indent))
-
-
-class ContinuedLineState:
-    """Tracker for continued indentation inside a logical line."""
-
-    def __init__(self, tokens, config):
-        self._line_start = -1
-        self._cont_stack = []
-        self._is_block_opener = False
-        self.retained_warnings = []
-        self._config = config
-        self._tokens = TokenWrapper(tokens)
-
-    @property
-    def has_content(self):
-        return bool(self._cont_stack)
-
-    @property
-    def _block_indent_string(self):
-        return self._config.indent_string.replace("\\t", "\t")
-
-    @property
-    def _continuation_string(self):
-        return self._block_indent_string[0] * self._config.indent_after_paren
-
-    @property
-    def _continuation_size(self):
-        return self._config.indent_after_paren
-
-    def handle_line_start(self, pos):
-        """Record the first non-junk token at the start of a line."""
-        if self._line_start > -1:
-            return
-
-        check_token_position = pos
-        if self._tokens.token(pos) == _ASYNC_TOKEN:
-            check_token_position += 1
-        self._is_block_opener = (
-            self._tokens.token(check_token_position) in _CONTINUATION_BLOCK_OPENERS
-        )
-        self._line_start = pos
-
-    def next_physical_line(self):
-        """Prepares the tracker for a new physical line (NL)."""
-        self._line_start = -1
-        self._is_block_opener = False
-
-    def next_logical_line(self):
-        """Prepares the tracker for a new logical line (NEWLINE).
-
-        A new logical line only starts with block indentation.
-        """
-        self.next_physical_line()
-        self.retained_warnings = []
-        self._cont_stack = []
-
-    def add_block_warning(self, token_position, state, valid_indentations):
-        self.retained_warnings.append((token_position, state, valid_indentations))
-
-    def get_valid_indentations(self, idx):
-        """Returns the valid offsets for the token at the given position."""
-        # The closing brace on a dict or the 'for' in a dict comprehension may
-        # reset two indent levels because the dict value is ended implicitly
-        stack_top = -1
-        if (
-            self._tokens.token(idx) in ("}", "for")
-            and self._cont_stack[-1].token == ":"
-        ):
-            stack_top = -2
-        indent = self._cont_stack[stack_top]
-        if self._tokens.token(idx) in _CLOSING_BRACKETS:
-            valid_indentations = indent.valid_outdent_strings
-        else:
-            valid_indentations = indent.valid_continuation_strings
-        return indent, valid_indentations.copy()
-
-    def _hanging_indent_after_bracket(self, bracket, position):
-        """Extracts indentation information for a hanging indent
-
-        Case of hanging indent after a bracket (including parenthesis)
-
-        :param str bracket: bracket in question
-        :param int position: Position of bracket in self._tokens
-
-        :returns: the state and valid positions for hanging indentation
-        :rtype: _ContinuedIndent
-        """
-        indentation = self._tokens.line_indent(position)
-        if (
-            self._is_block_opener
-            and self._continuation_string == self._block_indent_string
-        ):
-            return _ContinuedIndent(
-                HANGING_BLOCK,
-                bracket,
-                position,
-                _Indentations(indentation + self._continuation_string, indentation),
-                _BeforeBlockIndentations(
-                    indentation + self._continuation_string,
-                    indentation + self._continuation_string * 2,
-                ),
-            )
-        if bracket == ":":
-            # If the dict key was on the same line as the open brace, the new
-            # correct indent should be relative to the key instead of the
-            # current indent level
-            paren_align = self._cont_stack[-1].valid_outdent_strings
-            next_align = self._cont_stack[-1].valid_continuation_strings.copy()
-            next_align_keys = list(next_align.keys())
-            next_align[next_align_keys[0] + self._continuation_string] = True
-            # Note that the continuation of
-            # d = {
-            #       'a': 'b'
-            #            'c'
-            # }
-            # is handled by the special-casing for hanging continued string indents.
-            return _ContinuedIndent(
-                HANGING_DICT_VALUE, bracket, position, paren_align, next_align
-            )
-        return _ContinuedIndent(
-            HANGING,
-            bracket,
-            position,
-            _Indentations(indentation, indentation + self._continuation_string),
-            _Indentations(indentation + self._continuation_string),
-        )
-
-    def _continuation_inside_bracket(self, bracket, position):
-        """Extracts indentation information for a continued indent."""
-        indentation = self._tokens.line_indent(position)
-        token_indent = self._tokens.token_indent(position)
-        next_token_indent = self._tokens.token_indent(position + 1)
-        if (
-            self._is_block_opener
-            and next_token_indent == indentation + self._block_indent_string
-        ):
-            return _ContinuedIndent(
-                CONTINUED_BLOCK,
-                bracket,
-                position,
-                _Indentations(token_indent),
-                _BeforeBlockIndentations(
-                    next_token_indent, next_token_indent + self._continuation_string
-                ),
-            )
-        return _ContinuedIndent(
-            CONTINUED,
-            bracket,
-            position,
-            _Indentations(token_indent, next_token_indent),
-            _Indentations(next_token_indent),
-        )
-
-    def pop_token(self):
-        self._cont_stack.pop()
-
-    def push_token(self, token, position):
-        """Pushes a new token for continued indentation on the stack.
-
-        Tokens that can modify continued indentation offsets are:
-          * opening brackets
-          * 'lambda'
-          * : inside dictionaries
-
-        push_token relies on the caller to filter out those
-        interesting tokens.
-
-        :param int token: The concrete token
-        :param int position: The position of the token in the stream.
-        """
-        if _token_followed_by_eol(self._tokens, position):
-            self._cont_stack.append(self._hanging_indent_after_bracket(token, position))
-        else:
-            self._cont_stack.append(self._continuation_inside_bracket(token, position))
-
-
-class FormatChecker(BaseTokenChecker):
-    """checks for :
-    * unauthorized constructions
-    * strict indentation
-    * line length
-    """
-
-    __implements__ = (ITokenChecker, IAstroidChecker, IRawChecker)
-
-    # configuration section name
-    name = "format"
-    # messages
-    msgs = MSGS
-    # configuration options
-    # for available dict keys/values see the optik parser 'add_option' method
-    options = (
-        (
-            "max-line-length",
-            {
-                "default": 100,
-                "type": "int",
-                "metavar": "<int>",
-                "help": "Maximum number of characters on a single line.",
-            },
-        ),
-        (
-            "ignore-long-lines",
-            {
-                "type": "regexp",
-                "metavar": "<regexp>",
-                "default": r"^\s*(# )?<?https?://\S+>?$",
-                "help": (
-                    "Regexp for a line that is allowed to be longer than " "the limit."
-                ),
-            },
-        ),
-        (
-            "single-line-if-stmt",
-            {
-                "default": False,
-                "type": "yn",
-                "metavar": "<y_or_n>",
-                "help": (
-                    "Allow the body of an if to be on the same "
-                    "line as the test if there is no else."
-                ),
-            },
-        ),
-        (
-            "single-line-class-stmt",
-            {
-                "default": False,
-                "type": "yn",
-                "metavar": "<y_or_n>",
-                "help": (
-                    "Allow the body of a class to be on the same "
-                    "line as the declaration if body contains "
-                    "single statement."
-                ),
-            },
-        ),
-        (
-            "no-space-check",
-            {
-                "default": ",".join(_DEFAULT_NO_SPACE_CHECK_CHOICES),
-                "metavar": ",".join(_NO_SPACE_CHECK_CHOICES),
-                "type": "multiple_choice",
-                "choices": _NO_SPACE_CHECK_CHOICES,
-                "help": (
-                    "List of optional constructs for which whitespace "
-                    "checking is disabled. "
-                    "`" + _DICT_SEPARATOR + "` is used to allow tabulation "
-                    "in dicts, etc.: {1  : 1,\\n222: 2}. "
-                    "`" + _TRAILING_COMMA + "` allows a space between comma "
-                    "and closing bracket: (a, ). "
-                    "`" + _EMPTY_LINE + "` allows space-only lines."
-                ),
-            },
-        ),
-        (
-            "max-module-lines",
-            {
-                "default": 1000,
-                "type": "int",
-                "metavar": "<int>",
-                "help": "Maximum number of lines in a module.",
-            },
-        ),
-        (
-            "indent-string",
-            {
-                "default": "    ",
-                "type": "non_empty_string",
-                "metavar": "<string>",
-                "help": "String used as indentation unit. This is usually "
-                '"    " (4 spaces) or "\\t" (1 tab).',
-            },
-        ),
-        (
-            "indent-after-paren",
-            {
-                "type": "int",
-                "metavar": "<int>",
-                "default": 4,
-                "help": "Number of spaces of indent required inside a hanging "
-                "or continued line.",
-            },
-        ),
-        (
-            "expected-line-ending-format",
-            {
-                "type": "choice",
-                "metavar": "<empty or LF or CRLF>",
-                "default": "",
-                "choices": ["", "LF", "CRLF"],
-                "help": (
-                    "Expected format of line ending, "
-                    "e.g. empty (any line ending), LF or CRLF."
-                ),
-            },
-        ),
-    )
-
-    def __init__(self, linter=None):
-        BaseTokenChecker.__init__(self, linter)
-        self._lines = None
-        self._visited_lines = None
-        self._bracket_stack = [None]
-
-    def _pop_token(self):
-        self._bracket_stack.pop()
-        self._current_line.pop_token()
-
-    def _push_token(self, token, idx):
-        self._bracket_stack.append(token)
-        self._current_line.push_token(token, idx)
-
-    def new_line(self, tokens, line_end, line_start):
-        """a new line has been encountered, process it if necessary"""
-        if _last_token_on_line_is(tokens, line_end, ";"):
-            self.add_message("unnecessary-semicolon", line=tokens.start_line(line_end))
-
-        line_num = tokens.start_line(line_start)
-        line = tokens.line(line_start)
-        if tokens.type(line_start) not in _JUNK_TOKENS:
-            self._lines[line_num] = line.split("\n")[0]
-        self.check_lines(line, line_num)
-
-    def process_module(self, _module):
-        self._keywords_with_parens = set()
-
-    def _check_keyword_parentheses(self, tokens, start):
-        """Check that there are not unnecessary parens after a keyword.
-
-        Parens are unnecessary if there is exactly one balanced outer pair on a
-        line, and it is followed by a colon, and contains no commas (i.e. is not a
-        tuple).
-
-        Args:
-        tokens: list of Tokens; the entire list of Tokens.
-        start: int; the position of the keyword in the token list.
-        """
-        # If the next token is not a paren, we're fine.
-        if self._inside_brackets(":") and tokens[start][1] == "for":
-            self._pop_token()
-        if tokens[start + 1][1] != "(":
-            return
-
-        found_and_or = False
-        depth = 0
-        keyword_token = str(tokens[start][1])
-        line_num = tokens[start][2][0]
-
-        for i in range(start, len(tokens) - 1):
-            token = tokens[i]
-
-            # If we hit a newline, then assume any parens were for continuation.
-            if token[0] == tokenize.NL:
-                return
-
-            if token[1] == "(":
-                depth += 1
-            elif token[1] == ")":
-                depth -= 1
-                if depth:
-                    continue
-                # ')' can't happen after if (foo), since it would be a syntax error.
-                if tokens[i + 1][1] in (":", ")", "]", "}", "in") or tokens[i + 1][
-                    0
-                ] in (tokenize.NEWLINE, tokenize.ENDMARKER, tokenize.COMMENT):
-                    # The empty tuple () is always accepted.
-                    if i == start + 2:
-                        return
-                    if keyword_token == "not":
-                        if not found_and_or:
-                            self.add_message(
-                                "superfluous-parens", line=line_num, args=keyword_token
-                            )
-                    elif keyword_token in ("return", "yield"):
-                        self.add_message(
-                            "superfluous-parens", line=line_num, args=keyword_token
-                        )
-                    elif keyword_token not in self._keywords_with_parens:
-                        if not found_and_or:
-                            self.add_message(
-                                "superfluous-parens", line=line_num, args=keyword_token
-                            )
-                return
-            elif depth == 1:
-                # This is a tuple, which is always acceptable.
-                if token[1] == ",":
-                    return
-                # 'and' and 'or' are the only boolean operators with lower precedence
-                # than 'not', so parens are only required when they are found.
-                if token[1] in ("and", "or"):
-                    found_and_or = True
-                # A yield inside an expression must always be in parentheses,
-                # quit early without error.
-                elif token[1] == "yield":
-                    return
-                # A generator expression always has a 'for' token in it, and
-                # the 'for' token is only legal inside parens when it is in a
-                # generator expression.  The parens are necessary here, so bail
-                # without an error.
-                elif token[1] == "for":
-                    return
-
-    def _opening_bracket(self, tokens, i):
-        self._push_token(tokens[i][1], i)
-        # Special case: ignore slices
-        if tokens[i][1] == "[" and tokens[i + 1][1] == ":":
-            return
-
-        if i > 0 and (
-            tokens[i - 1][0] == tokenize.NAME
-            and not (keyword.iskeyword(tokens[i - 1][1]))
-            or tokens[i - 1][1] in _CLOSING_BRACKETS
-        ):
-            self._check_space(tokens, i, (_MUST_NOT, _MUST_NOT))
-        else:
-            self._check_space(tokens, i, (_IGNORE, _MUST_NOT))
-
-    def _closing_bracket(self, tokens, i):
-        if self._inside_brackets(":"):
-            self._pop_token()
-        self._pop_token()
-        # Special case: ignore slices
-        if tokens[i - 1][1] == ":" and tokens[i][1] == "]":
-            return
-        policy_before = _MUST_NOT
-        if tokens[i][1] in _CLOSING_BRACKETS and tokens[i - 1][1] == ",":
-            if _TRAILING_COMMA in self.config.no_space_check:
-                policy_before = _IGNORE
-
-        self._check_space(tokens, i, (policy_before, _IGNORE))
-
-    def _has_valid_type_annotation(self, tokens, i):
-        """Extended check of PEP-484 type hint presence"""
-        if not self._inside_brackets("("):
-            return False
-        # token_info
-        # type string start end line
-        #  0      1     2    3    4
-        bracket_level = 0
-        for token in tokens[i - 1 :: -1]:
-            if token[1] == ":":
-                return True
-            if token[1] == "(":
-                return False
-            if token[1] == "]":
-                bracket_level += 1
-            elif token[1] == "[":
-                bracket_level -= 1
-            elif token[1] == ",":
-                if not bracket_level:
-                    return False
-            elif token[1] in (".", "..."):
-                continue
-            elif token[0] not in (tokenize.NAME, tokenize.STRING, tokenize.NL):
-                return False
-        return False
-
-    def _check_equals_spacing(self, tokens, i):
-        """Check the spacing of a single equals sign."""
-        if self._has_valid_type_annotation(tokens, i):
-            self._check_space(tokens, i, (_MUST, _MUST))
-        elif self._inside_brackets("(") or self._inside_brackets("lambda"):
-            self._check_space(tokens, i, (_MUST_NOT, _MUST_NOT))
-        else:
-            self._check_space(tokens, i, (_MUST, _MUST))
-
-    def _open_lambda(self, tokens, i):  # pylint:disable=unused-argument
-        self._push_token("lambda", i)
-
-    def _handle_colon(self, tokens, i):
-        # Special case: ignore slices
-        if self._inside_brackets("["):
-            return
-        if self._inside_brackets("{") and _DICT_SEPARATOR in self.config.no_space_check:
-            policy = (_IGNORE, _IGNORE)
-        else:
-            policy = (_MUST_NOT, _MUST)
-        self._check_space(tokens, i, policy)
-
-        if self._inside_brackets("lambda"):
-            self._pop_token()
-        elif self._inside_brackets("{"):
-            self._push_token(":", i)
-
-    def _handle_comma(self, tokens, i):
-        # Only require a following whitespace if this is
-        # not a hanging comma before a closing bracket.
-        if tokens[i + 1][1] in _CLOSING_BRACKETS:
-            self._check_space(tokens, i, (_MUST_NOT, _IGNORE))
-        else:
-            self._check_space(tokens, i, (_MUST_NOT, _MUST))
-        if self._inside_brackets(":"):
-            self._pop_token()
-
-    def _check_surrounded_by_space(self, tokens, i):
-        """Check that a binary operator is surrounded by exactly one space."""
-        self._check_space(tokens, i, (_MUST, _MUST))
-
-    def _check_space(self, tokens, i, policies):
-        def _policy_string(policy):
-            if policy == _MUST:
-                return "Exactly one", "required"
-            return "No", "allowed"
-
-        def _name_construct(token):
-            if token[1] == ",":
-                return "comma"
-            if token[1] == ":":
-                return ":"
-            if token[1] in "()[]{}":
-                return "bracket"
-            if token[1] in ("<", ">", "<=", ">=", "!=", "=="):
-                return "comparison"
-            if self._inside_brackets("("):
-                return "keyword argument assignment"
-            return "assignment"
-
-        good_space = [True, True]
-        token = tokens[i]
-        pairs = [(tokens[i - 1], token), (token, tokens[i + 1])]
-
-        for other_idx, (policy, token_pair) in enumerate(zip(policies, pairs)):
-            if token_pair[other_idx][0] in _EOL or policy == _IGNORE:
-                continue
-
-            distance = _column_distance(*token_pair)
-            if distance is None:
-                continue
-            good_space[other_idx] = (policy == _MUST and distance == 1) or (
-                policy == _MUST_NOT and distance == 0
-            )
-
-        warnings = []
-        if not any(good_space) and policies[0] == policies[1]:
-            warnings.append((policies[0], "around"))
-        else:
-            for ok, policy, position in zip(good_space, policies, ("before", "after")):
-                if not ok:
-                    warnings.append((policy, position))
-        for policy, position in warnings:
-            construct = _name_construct(token)
-            count, state = _policy_string(policy)
-            self.add_message(
-                "bad-whitespace",
-                line=token[2][0],
-                args=(count, state, position, construct, _underline_token(token)),
-                col_offset=token[2][1],
-            )
-
-    def _inside_brackets(self, left):
-        return self._bracket_stack[-1] == left
-
-    def _prepare_token_dispatcher(self):
-        raw = [
-            (_KEYWORD_TOKENS, self._check_keyword_parentheses),
-            (_OPENING_BRACKETS, self._opening_bracket),
-            (_CLOSING_BRACKETS, self._closing_bracket),
-            (["="], self._check_equals_spacing),
-            (_SPACED_OPERATORS, self._check_surrounded_by_space),
-            ([","], self._handle_comma),
-            ([":"], self._handle_colon),
-            (["lambda"], self._open_lambda),
-        ]
-
-        dispatch = {}
-        for tokens, handler in raw:
-            for token in tokens:
-                dispatch[token] = handler
-        return dispatch
-
-    def process_tokens(self, tokens):
-        """process tokens and search for :
-
-         _ non strict indentation (i.e. not always using the <indent> parameter as
-           indent unit)
-         _ too long lines (i.e. longer than <max_chars>)
-         _ optionally bad construct (if given, bad_construct must be a compiled
-           regular expression).
-        """
-        self._bracket_stack = [None]
-        indents = [0]
-        check_equal = False
-        line_num = 0
-        self._lines = {}
-        self._visited_lines = {}
-        token_handlers = self._prepare_token_dispatcher()
-        self._last_line_ending = None
-        last_blank_line_num = 0
-
-        self._current_line = ContinuedLineState(tokens, self.config)
-        for idx, (tok_type, token, start, _, line) in enumerate(tokens):
-            if start[0] != line_num:
-                line_num = start[0]
-                # A tokenizer oddity: if an indented line contains a multi-line
-                # docstring, the line member of the INDENT token does not contain
-                # the full line; therefore we check the next token on the line.
-                if tok_type == tokenize.INDENT:
-                    self.new_line(TokenWrapper(tokens), idx - 1, idx + 1)
-                else:
-                    self.new_line(TokenWrapper(tokens), idx - 1, idx)
-
-            if tok_type == tokenize.NEWLINE:
-                # a program statement, or ENDMARKER, will eventually follow,
-                # after some (possibly empty) run of tokens of the form
-                #     (NL | COMMENT)* (INDENT | DEDENT+)?
-                # If an INDENT appears, setting check_equal is wrong, and will
-                # be undone when we see the INDENT.
-                check_equal = True
-                self._process_retained_warnings(TokenWrapper(tokens), idx)
-                self._current_line.next_logical_line()
-                self._check_line_ending(token, line_num)
-            elif tok_type == tokenize.INDENT:
-                check_equal = False
-                self.check_indent_level(token, indents[-1] + 1, line_num)
-                indents.append(indents[-1] + 1)
-            elif tok_type == tokenize.DEDENT:
-                # there's nothing we need to check here!  what's important is
-                # that when the run of DEDENTs ends, the indentation of the
-                # program statement (or ENDMARKER) that triggered the run is
-                # equal to what's left at the top of the indents stack
-                check_equal = True
-                if len(indents) > 1:
-                    del indents[-1]
-            elif tok_type == tokenize.NL:
-                if not line.strip("\r\n"):
-                    last_blank_line_num = line_num
-                self._check_continued_indentation(TokenWrapper(tokens), idx + 1)
-                self._current_line.next_physical_line()
-            elif tok_type not in (tokenize.COMMENT, tokenize.ENCODING):
-                self._current_line.handle_line_start(idx)
-                # This is the first concrete token following a NEWLINE, so it
-                # must be the first token of the next program statement, or an
-                # ENDMARKER; the "line" argument exposes the leading whitespace
-                # for this statement; in the case of ENDMARKER, line is an empty
-                # string, so will properly match the empty string with which the
-                # "indents" stack was seeded
-                if check_equal:
-                    check_equal = False
-                    self.check_indent_level(line, indents[-1], line_num)
-
-            if tok_type == tokenize.NUMBER and token.endswith("l"):
-                self.add_message("lowercase-l-suffix", line=line_num)
-
-            try:
-                handler = token_handlers[token]
-            except KeyError:
-                pass
-            else:
-                handler(tokens, idx)
-
-        line_num -= 1  # to be ok with "wc -l"
-        if line_num > self.config.max_module_lines:
-            # Get the line where the too-many-lines (or its message id)
-            # was disabled or default to 1.
-            message_definition = self.linter.msgs_store.get_message_definitions(
-                "too-many-lines"
-            )[0]
-            names = (message_definition.msgid, "too-many-lines")
-            line = next(filter(None, map(self.linter._pragma_lineno.get, names)), 1)
-            self.add_message(
-                "too-many-lines",
-                args=(line_num, self.config.max_module_lines),
-                line=line,
-            )
-
-        # See if there are any trailing lines.  Do not complain about empty
-        # files like __init__.py markers.
-        if line_num == last_blank_line_num and line_num > 0:
-            self.add_message("trailing-newlines", line=line_num)
-
-    def _check_line_ending(self, line_ending, line_num):
-        # check if line endings are mixed
-        if self._last_line_ending is not None:
-            # line_ending == "" indicates a synthetic newline added at
-            # the end of a file that does not, in fact, end with a
-            # newline.
-            if line_ending and line_ending != self._last_line_ending:
-                self.add_message("mixed-line-endings", line=line_num)
-
-        self._last_line_ending = line_ending
-
-        # check if line ending is as expected
-        expected = self.config.expected_line_ending_format
-        if expected:
-            # reduce multiple \n\n\n\n to one \n
-            line_ending = reduce(lambda x, y: x + y if x != y else x, line_ending, "")
-            line_ending = "LF" if line_ending == "\n" else "CRLF"
-            if line_ending != expected:
-                self.add_message(
-                    "unexpected-line-ending-format",
-                    args=(line_ending, expected),
-                    line=line_num,
-                )
-
-    def _process_retained_warnings(self, tokens, current_pos):
-        single_line_block_stmt = not _last_token_on_line_is(tokens, current_pos, ":")
-
-        for indent_pos, state, indentations in self._current_line.retained_warnings:
-            block_type = indentations[tokens.token_indent(indent_pos)]
-            hints = {k: v for k, v in indentations.items() if v != block_type}
-            if single_line_block_stmt and block_type == WITH_BODY:
-                self._add_continuation_message(state, hints, tokens, indent_pos)
-            elif not single_line_block_stmt and block_type == SINGLE_LINE:
-                self._add_continuation_message(state, hints, tokens, indent_pos)
-
-    def _check_continued_indentation(self, tokens, next_idx):
-        def same_token_around_nl(token_type):
-            return (
-                tokens.type(next_idx) == token_type
-                and tokens.type(next_idx - 2) == token_type
-            )
-
-        # Do not issue any warnings if the next line is empty.
-        if not self._current_line.has_content or tokens.type(next_idx) == tokenize.NL:
-            return
-
-        state, valid_indentations = self._current_line.get_valid_indentations(next_idx)
-        # Special handling for hanging comments and strings. If the last line ended
-        # with a comment (string) and the new line contains only a comment, the line
-        # may also be indented to the start of the previous token.
-        if same_token_around_nl(tokenize.COMMENT) or same_token_around_nl(
-            tokenize.STRING
-        ):
-            valid_indentations[tokens.token_indent(next_idx - 2)] = True
-
-        # We can only decide if the indentation of a continued line before opening
-        # a new block is valid once we know of the body of the block is on the
-        # same line as the block opener. Since the token processing is single-pass,
-        # emitting those warnings is delayed until the block opener is processed.
-        if (
-            state.context_type in (HANGING_BLOCK, CONTINUED_BLOCK)
-            and tokens.token_indent(next_idx) in valid_indentations
-        ):
-            self._current_line.add_block_warning(next_idx, state, valid_indentations)
-        elif tokens.token_indent(next_idx) not in valid_indentations:
-            length_indentation = len(tokens.token_indent(next_idx))
-            if not any(
-                length_indentation == 2 * len(indentation)
-                for indentation in valid_indentations
-            ):
-                self._add_continuation_message(
-                    state, valid_indentations, tokens, next_idx
-                )
-
-    def _add_continuation_message(self, state, indentations, tokens, position):
-        readable_type, readable_position = _CONTINUATION_MSG_PARTS[state.context_type]
-        hint_line, delta_message = _get_indent_hint_line(
-            indentations, tokens.token_indent(position)
-        )
-        self.add_message(
-            "bad-continuation",
-            line=tokens.start_line(position),
-            args=(
-                readable_type,
-                readable_position,
-                delta_message,
-                tokens.line(position),
-                hint_line,
-            ),
-        )
-
-    @check_messages("multiple-statements")
-    def visit_default(self, node):
-        """check the node line number and check it if not yet done"""
-        if not node.is_statement:
-            return
-        if not node.root().pure_python:
-            return
-        prev_sibl = node.previous_sibling()
-        if prev_sibl is not None:
-            prev_line = prev_sibl.fromlineno
-        else:
-            # The line on which a finally: occurs in a try/finally
-            # is not directly represented in the AST. We infer it
-            # by taking the last line of the body and adding 1, which
-            # should be the line of finally:
-            if (
-                isinstance(node.parent, nodes.TryFinally)
-                and node in node.parent.finalbody
-            ):
-                prev_line = node.parent.body[0].tolineno + 1
-            else:
-                prev_line = node.parent.statement().fromlineno
-        line = node.fromlineno
-        assert line, node
-        if prev_line == line and self._visited_lines.get(line) != 2:
-            self._check_multi_statement_line(node, line)
-            return
-        if line in self._visited_lines:
-            return
-        try:
-            tolineno = node.blockstart_tolineno
-        except AttributeError:
-            tolineno = node.tolineno
-        assert tolineno, node
-        lines = []
-        for line in range(line, tolineno + 1):
-            self._visited_lines[line] = 1
-            try:
-                lines.append(self._lines[line].rstrip())
-            except KeyError:
-                lines.append("")
-
-    def _check_multi_statement_line(self, node, line):
-        """Check for lines containing multiple statements."""
-        # Do not warn about multiple nested context managers
-        # in with statements.
-        if isinstance(node, nodes.With):
-            return
-        # For try... except... finally..., the two nodes
-        # appear to be on the same line due to how the AST is built.
-        if isinstance(node, nodes.TryExcept) and isinstance(
-            node.parent, nodes.TryFinally
-        ):
-            return
-        if (
-            isinstance(node.parent, nodes.If)
-            and not node.parent.orelse
-            and self.config.single_line_if_stmt
-        ):
-            return
-        if (
-            isinstance(node.parent, nodes.ClassDef)
-            and len(node.parent.body) == 1
-            and self.config.single_line_class_stmt
-        ):
-            return
-        self.add_message("multiple-statements", node=node)
-        self._visited_lines[line] = 2
-
-    def check_lines(self, lines, i):
-        """check lines have less than a maximum number of characters
-        """
-        max_chars = self.config.max_line_length
-        ignore_long_line = self.config.ignore_long_lines
-
-        def check_line(line, i):
-            if not line.endswith("\n"):
-                self.add_message("missing-final-newline", line=i)
-            else:
-                # exclude \f (formfeed) from the rstrip
-                stripped_line = line.rstrip("\t\n\r\v ")
-                if not stripped_line and _EMPTY_LINE in self.config.no_space_check:
-                    # allow empty lines
-                    pass
-                elif line[len(stripped_line) :] not in ("\n", "\r\n"):
-                    self.add_message(
-                        "trailing-whitespace", line=i, col_offset=len(stripped_line)
-                    )
-                # Don't count excess whitespace in the line length.
-                line = stripped_line
-            mobj = OPTION_RGX.search(line)
-            if mobj and "=" in line:
-                front_of_equal, _, back_of_equal = mobj.group(1).partition("=")
-                if front_of_equal.strip() == "disable":
-                    if "line-too-long" in {
-                        _msg_id.strip() for _msg_id in back_of_equal.split(",")
-                    }:
-                        return None
-                    line = line.rsplit("#", 1)[0].rstrip()
-
-            if len(line) > max_chars and not ignore_long_line.search(line):
-                self.add_message("line-too-long", line=i, args=(len(line), max_chars))
-            return i + 1
-
-        unsplit_ends = {
-            "\v",
-            "\x0b",
-            "\f",
-            "\x0c",
-            "\x1c",
-            "\x1d",
-            "\x1e",
-            "\x85",
-            "\u2028",
-            "\u2029",
-        }
-        unsplit = []
-        for line in lines.splitlines(True):
-            if line[-1] in unsplit_ends:
-                unsplit.append(line)
-                continue
-
-            if unsplit:
-                unsplit.append(line)
-                line = "".join(unsplit)
-                unsplit = []
-
-            i = check_line(line, i)
-            if i is None:
-                break
-
-        if unsplit:
-            check_line("".join(unsplit), i)
-
-    def check_indent_level(self, string, expected, line_num):
-        """return the indent level of the string
-        """
-        indent = self.config.indent_string
-        if indent == "\\t":  # \t is not interpreted in the configuration file
-            indent = "\t"
-        level = 0
-        unit_size = len(indent)
-        while string[:unit_size] == indent:
-            string = string[unit_size:]
-            level += 1
-        suppl = ""
-        while string and string[0] in " \t":
-            if string[0] != indent[0]:
-                if string[0] == "\t":
-                    args = ("tab", "space")
-                else:
-                    args = ("space", "tab")
-                self.add_message("mixed-indentation", args=args, line=line_num)
-                return level
-            suppl += string[0]
-            string = string[1:]
-        if level != expected or suppl:
-            i_type = "spaces"
-            if indent[0] == "\t":
-                i_type = "tabs"
-            self.add_message(
-                "bad-indentation",
-                line=line_num,
-                args=(level * unit_size + len(suppl), i_type, expected * unit_size),
-            )
-        return None
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(FormatChecker(linter))