SYMBOL INDEX (1494 symbols across 60 files)

FILE: third_party/yapf_third_party/_ylib2to3/fixer_base.py
  class BaseFix (line 14) | class BaseFix(object):
    method __init__ (line 46) | def __init__(self, options, log):
    method compile_pattern (line 58) | def compile_pattern(self):
    method set_filename (line 69) | def set_filename(self, filename):
    method match (line 76) | def match(self, node):
    method transform (line 88) | def transform(self, node, results):
    method new_name (line 104) | def new_name(self, template='xxx_todo_changeme'):
    method log_message (line 115) | def log_message(self, message):
    method cannot_convert (line 121) | def cannot_convert(self, node, reason=None):
    method warning (line 136) | def warning(self, node, reason):
    method start_tree (line 145) | def start_tree(self, tree, filename):
    method finish_tree (line 158) | def finish_tree(self, tree, filename):
  class ConditionalFix (line 169) | class ConditionalFix(BaseFix):
    method start_tree (line 176) | def start_tree(self, *args):
    method should_skip (line 180) | def should_skip(self, node):

FILE: third_party/yapf_third_party/_ylib2to3/fixer_util.py
  function KeywordArg (line 16) | def KeywordArg(keyword, value):
  function LParen (line 20) | def LParen():
  function RParen (line 24) | def RParen():
  function Assign (line 28) | def Assign(target, source):
  function Name (line 39) | def Name(name, prefix=None):
  function Attr (line 44) | def Attr(obj, attr):
  function Comma (line 49) | def Comma():
  function Dot (line 54) | def Dot():
  function ArgList (line 59) | def ArgList(args, lparen=LParen(), rparen=RParen()):
  function Call (line 67) | def Call(func_name, args=None, prefix=None):
  function Newline (line 75) | def Newline():
  function BlankLine (line 80) | def BlankLine():
  function Number (line 85) | def Number(n, prefix=None):
  function Subscript (line 89) | def Subscript(index_node):
  function String (line 96) | def String(string, prefix=None):
  function ListComp (line 101) | def ListComp(xp, fp, it, test=None):
  function FromImport (line 125) | def FromImport(package_name, name_leafs):
  function ImportAndCall (line 149) | def ImportAndCall(node, results, names):
  function is_tuple (line 178) | def is_tuple(node):
  function is_list (line 189) | def is_list(node):
  function parenthesize (line 202) | def parenthesize(node):
  function attr_chain (line 212) | def attr_chain(obj, attr):
  function in_special_context (line 253) | def in_special_context(node):
  function is_probably_builtin (line 273) | def is_probably_builtin(node):
  function find_indentation (line 293) | def find_indentation(node):
  function make_suite (line 309) | def make_suite(node):
  function find_root (line 319) | def find_root(node):
  function does_tree_import (line 329) | def does_tree_import(package, name, node):
  function is_import (line 339) | def is_import(node):
  function touch_import (line 344) | def touch_import(package, name, node):
  function find_binding (line 393) | def find_binding(name, node, package=None):
  function _find (line 443) | def _find(name, node):
  function _is_import_binding (line 454) | def _is_import_binding(node, name, package=None):

FILE: third_party/yapf_third_party/_ylib2to3/patcomp.py
  class PatternSyntaxError (line 27) | class PatternSyntaxError(Exception):
  function tokenize_wrapper (line 31) | def tokenize_wrapper(input):
  class PatternCompiler (line 41) | class PatternCompiler(object):
    method __init__ (line 43) | def __init__(self, grammar_file=None):
    method compile_pattern (line 58) | def compile_pattern(self, input, debug=False, with_tree=False):
    method compile_node (line 70) | def compile_node(self, node):
    method compile_basic (line 141) | def compile_basic(self, nodes, repeat=None):
    method get_int (line 176) | def get_int(self, node):
  function _type_of_literal (line 190) | def _type_of_literal(value):
  function pattern_convert (line 199) | def pattern_convert(grammar, raw_node_info):
  function compile_pattern (line 208) | def compile_pattern(pattern):

FILE: third_party/yapf_third_party/_ylib2to3/pgen2/conv.py
  class Converter (line 36) | class Converter(grammar.Grammar):
    method run (line 47) | def run(self, graminit_h, graminit_c):
    method parse_graminit_h (line 53) | def parse_graminit_h(self, filename):
    method parse_graminit_c (line 83) | def parse_graminit_c(self, filename):
    method finish_off (line 246) | def finish_off(self):

FILE: third_party/yapf_third_party/_ylib2to3/pgen2/driver.py
  class ReleaseRange (line 45) | class ReleaseRange:
    method lock (line 50) | def lock(self) -> None:
  class TokenProxy (line 55) | class TokenProxy:
    method __init__ (line 57) | def __init__(self, generator: Any) -> None:
    method release (line 63) | def release(self) -> Iterator['TokenProxy']:
    method eat (line 73) | def eat(self, point: int) -> Any:
    method __iter__ (line 83) | def __iter__(self) -> 'TokenProxy':
    method __next__ (line 86) | def __next__(self) -> Any:
    method can_advance (line 102) | def can_advance(self, to: int) -> bool:
  class Driver (line 113) | class Driver(object):
    method __init__ (line 115) | def __init__(self, grammar, convert=None, logger=None):
    method parse_tokens (line 122) | def parse_tokens(self, tokens, debug=False):
    method parse_stream_raw (line 170) | def parse_stream_raw(self, stream, debug=False):
    method parse_stream (line 175) | def parse_stream(self, stream, debug=False):
    method parse_file (line 179) | def parse_file(self, filename, encoding=None, debug=False):
    method parse_string (line 184) | def parse_string(self, text, debug=False):
  function _generate_pickle_name (line 190) | def _generate_pickle_name(gt):
  function load_grammar (line 214) | def load_grammar(gt='Grammar.txt',
  function _newer (line 252) | def _newer(a, b):
  function load_packaged_grammar (line 261) | def load_packaged_grammar(package, grammar_source):
  function main (line 281) | def main(*args):

FILE: third_party/yapf_third_party/_ylib2to3/pgen2/grammar.py
  class Grammar (line 23) | class Grammar(object):
    method __init__ (line 77) | def __init__(self):
    method dump (line 89) | def dump(self, filename):
    method load (line 125) | def load(self, filename):
    method loads (line 131) | def loads(self, pkl):
    method copy (line 135) | def copy(self):
    method report (line 148) | def report(self):

FILE: third_party/yapf_third_party/_ylib2to3/pgen2/literals.py
  function escape (line 21) | def escape(m):
  function evalString (line 43) | def evalString(s):
  function test (line 54) | def test():

FILE: third_party/yapf_third_party/_ylib2to3/pgen2/parse.py
  function stack_copy (line 38) | def stack_copy(
  class Recorder (line 44) | class Recorder:
    method __init__ (line 46) | def __init__(self, parser: 'Parser', ilabels: List[int],
    method ilabels (line 57) | def ilabels(self) -> Set[int]:
    method switch_to (line 61) | def switch_to(self, ilabel: int) -> Iterator[None]:
    method backtrack (line 72) | def backtrack(self) -> Iterator[None]:
    method add_token (line 88) | def add_token(self, tok_type: int, tok_val: Text, raw: bool = False) -...
    method determine_route (line 102) | def determine_route(self,
  class ParseError (line 117) | class ParseError(Exception):
    method __init__ (line 120) | def __init__(self, msg, type, value, context):
    method __reduce__ (line 128) | def __reduce__(self):
  class Parser (line 132) | class Parser(object):
    method __init__ (line 162) | def __init__(self, grammar, convert=None):
    method setup (line 195) | def setup(self, proxy, start=None):
    method addtoken (line 220) | def addtoken(self, type, value, context):
    method _addtoken (line 269) | def _addtoken(self, ilabel: int, type: int, value: Text,
    method classify (line 315) | def classify(self, type, value, context):
    method shift (line 338) | def shift(self, type: int, value: Text, newstate: int,
    method push (line 352) | def push(self, type: int, newdfa: DFAS, newstate: int,
    method pop (line 365) | def pop(self) -> None:

FILE: third_party/yapf_third_party/_ylib2to3/pgen2/pgen.py
  class PgenGrammar (line 12) | class PgenGrammar(grammar.Grammar):
  class ParserGenerator (line 16) | class ParserGenerator(object):
    method __init__ (line 18) | def __init__(self, filename=None, stream=None):
    method make_grammar (line 36) | def make_grammar(self):
    method make_first (line 61) | def make_first(self, c, name):
    method make_label (line 70) | def make_label(self, c, label):
    method addfirstsets (line 121) | def addfirstsets(self):
    method calcfirst (line 129) | def calcfirst(self, name):
    method parse (line 159) | def parse(self):
    method make_dfa (line 181) | def make_dfa(self, start, finish):
    method dump_nfa (line 220) | def dump_nfa(self, name, start, finish):
    method dump_dfa (line 236) | def dump_dfa(self, name, dfa):
    method simplify_dfa (line 243) | def simplify_dfa(self, dfa):
    method parse_rhs (line 264) | def parse_rhs(self):
    method parse_alt (line 281) | def parse_alt(self):
    method parse_item (line 290) | def parse_item(self):
    method parse_atom (line 310) | def parse_atom(self):
    method expect (line 327) | def expect(self, type, value=None):
    method gettoken (line 335) | def gettoken(self):
    method raise_error (line 342) | def raise_error(self, msg, *args):
  class NFAState (line 351) | class NFAState(object):
    method __init__ (line 353) | def __init__(self):
    method addarc (line 356) | def addarc(self, next, label=None):
  class DFAState (line 362) | class DFAState(object):
    method __init__ (line 364) | def __init__(self, nfaset, final):
    method addarc (line 372) | def addarc(self, next, label):
    method unifystate (line 378) | def unifystate(self, old, new):
    method __eq__ (line 383) | def __eq__(self, other):
  function generate_grammar (line 400) | def generate_grammar(filename_or_stream='Grammar.txt'):

FILE: third_party/yapf_third_party/_ylib2to3/pgen2/token.py
  function ISTERMINAL (line 79) | def ISTERMINAL(x):
  function ISNONTERMINAL (line 83) | def ISNONTERMINAL(x):
  function ISEOF (line 87) | def ISEOF(x):

FILE: third_party/yapf_third_party/_ylib2to3/pgen2/tokenize.py
  function group (line 64) | def group(*choices):
  function any (line 68) | def any(*choices):
  function maybe (line 72) | def maybe(*choices):
  function _combinations (line 76) | def _combinations(*l):  # noqa: E741
  class TokenError (line 164) | class TokenError(Exception):
  class StopTokenizing (line 168) | class StopTokenizing(Exception):
  function printtoken (line 172) | def printtoken(type, token, xxx_todo_changeme, xxx_todo_changeme1,
  function tokenize (line 180) | def tokenize(readline, tokeneater=printtoken):
  function tokenize_loop (line 200) | def tokenize_loop(readline, tokeneater):
  class Untokenizer (line 205) | class Untokenizer:
    method __init__ (line 207) | def __init__(self):
    method add_whitespace (line 212) | def add_whitespace(self, start):
    method untokenize (line 219) | def untokenize(self, iterable):
    method compat (line 233) | def compat(self, token, iterable):
  function _get_normal_name (line 266) | def _get_normal_name(orig_enc):
  function detect_encoding (line 278) | def detect_encoding(readline):
  function untokenize (line 353) | def untokenize(iterable):
  function generate_tokens (line 375) | def generate_tokens(readline):

FILE: third_party/yapf_third_party/_ylib2to3/pygram.py
  class Symbols (line 17) | class Symbols(object):
    method __init__ (line 19) | def __init__(self, grammar):

FILE: third_party/yapf_third_party/_ylib2to3/pytree.py
  function type_repr (line 27) | def type_repr(type_num):
  class Base (line 45) | class Base(object):
    method __new__ (line 62) | def __new__(cls, *args, **kwds):
    method __eq__ (line 67) | def __eq__(self, other):
    method _eq (line 79) | def _eq(self, other):
    method clone (line 90) | def clone(self):
    method post_order (line 98) | def post_order(self):
    method pre_order (line 106) | def pre_order(self):
    method replace (line 114) | def replace(self, new):
    method get_lineno (line 137) | def get_lineno(self):
    method changed (line 146) | def changed(self):
    method remove (line 151) | def remove(self):
    method next_sibling (line 165) | def next_sibling(self):
    method prev_sibling (line 182) | def prev_sibling(self):
    method leaves (line 197) | def leaves(self):
    method depth (line 201) | def depth(self):
    method get_suffix (line 206) | def get_suffix(self):
    method __str__ (line 218) | def __str__(self):
  class Node (line 222) | class Node(Base):
    method __init__ (line 225) | def __init__(self,
    method __repr__ (line 252) | def __repr__(self):
    method __unicode__ (line 257) | def __unicode__(self):
    method _eq (line 268) | def _eq(self, other):
    method clone (line 272) | def clone(self):
    method post_order (line 278) | def post_order(self):
    method pre_order (line 284) | def pre_order(self):
    method prefix (line 291) | def prefix(self):
    method prefix (line 300) | def prefix(self, prefix):
    method set_child (line 304) | def set_child(self, i, child):
    method insert_child (line 314) | def insert_child(self, i, child):
    method append_child (line 323) | def append_child(self, child):
  class Leaf (line 333) | class Leaf(Base):
    method __init__ (line 341) | def __init__(self, type, value, context=None, prefix=None, fixers_appl...
    method __repr__ (line 357) | def __repr__(self):
    method __unicode__ (line 361) | def __unicode__(self):
    method _eq (line 372) | def _eq(self, other):
    method clone (line 376) | def clone(self):
    method leaves (line 383) | def leaves(self):
    method post_order (line 386) | def post_order(self):
    method pre_order (line 390) | def pre_order(self):
    method prefix (line 395) | def prefix(self):
    method prefix (line 402) | def prefix(self, prefix):
  function convert (line 407) | def convert(gr, raw_node):
  class BasePattern (line 426) | class BasePattern(object):
    method __new__ (line 446) | def __new__(cls, *args, **kwds):
    method __repr__ (line 451) | def __repr__(self):
    method optimize (line 457) | def optimize(self):
    method match (line 465) | def match(self, node, results=None):
    method match_seq (line 490) | def match_seq(self, nodes, results=None):
    method generate_matches (line 500) | def generate_matches(self, nodes):
  class LeafPattern (line 511) | class LeafPattern(BasePattern):
    method __init__ (line 513) | def __init__(self, type=None, content=None, name=None):
    method match (line 533) | def match(self, node, results=None):
    method _submatch (line 539) | def _submatch(self, node, results=None):
  class NodePattern (line 555) | class NodePattern(BasePattern):
    method __init__ (line 559) | def __init__(self, type=None, content=None, name=None):
    method _submatch (line 588) | def _submatch(self, node, results=None):
  class WildcardPattern (line 616) | class WildcardPattern(BasePattern):
    method __init__ (line 629) | def __init__(self, content=None, min=0, max=HUGE, name=None):
    method optimize (line 664) | def optimize(self):
    method match (line 681) | def match(self, node, results=None):
    method match_seq (line 685) | def match_seq(self, nodes, results=None):
    method generate_matches (line 696) | def generate_matches(self, nodes):
    method _iterative_matches (line 741) | def _iterative_matches(self, nodes):
    method _bare_name_matches (line 770) | def _bare_name_matches(self, nodes):
    method _recursive_matches (line 786) | def _recursive_matches(self, nodes, count):
  class NegatedPattern (line 801) | class NegatedPattern(BasePattern):
    method __init__ (line 803) | def __init__(self, content=None):
    method match (line 816) | def match(self, node):
    method match_seq (line 820) | def match_seq(self, nodes):
    method generate_matches (line 824) | def generate_matches(self, nodes):
  function generate_matches (line 836) | def generate_matches(patterns, nodes):

FILE: third_party/yapf_third_party/yapf_diff/yapf_diff.py
  function main (line 36) | def main():

FILE: yapf/__init__.py
  function _raw_input (line 43) | def _raw_input():
  function _removeBOM (line 48) | def _removeBOM(source):
  function main (line 57) | def main(argv):
  function _PrintHelp (line 150) | def _PrintHelp(args):
  function FormatFiles (line 167) | def FormatFiles(filenames,
  function _FormatFile (line 220) | def _FormatFile(filename,
  function _GetLines (line 258) | def _GetLines(line_strings):
  function _BuildParser (line 283) | def _BuildParser():
  function run_main (line 375) | def run_main():  # pylint: disable=invalid-name

FILE: yapf/pyparser/pyparser.py
  function ParseCode (line 50) | def ParseCode(unformatted_source, filename='<unknown>'):
  function _CreateLogicalLines (line 84) | def _CreateLogicalLines(tokens):

FILE: yapf/pyparser/pyparser_utils.py
  function GetLogicalLine (line 32) | def GetLogicalLine(logical_lines, node):
  function GetTokensInSubRange (line 47) | def GetTokensInSubRange(tokens, node):
  function GetTokenIndex (line 61) | def GetTokenIndex(tokens, pos):
  function GetNextTokenIndex (line 70) | def GetNextTokenIndex(tokens, pos):
  function GetPrevTokenIndex (line 79) | def GetPrevTokenIndex(tokens, pos):
  function TokenStart (line 88) | def TokenStart(node):
  function TokenEnd (line 92) | def TokenEnd(node):
  function AstDump (line 101) | def AstDump(node):

FILE: yapf/pyparser/split_penalty_visitor.py
  class SplitPenalty (line 23) | class SplitPenalty(ast.NodeVisitor):
    method __init__ (line 26) | def __init__(self, logical_lines):
    method _GetTokens (line 36) | def _GetTokens(self, node):
    method visit_FunctionDef (line 43) | def visit_FunctionDef(self, node):
    method visit_AsyncFunctionDef (line 80) | def visit_AsyncFunctionDef(self, node):
    method visit_ClassDef (line 94) | def visit_ClassDef(self, node):
    method visit_Return (line 111) | def visit_Return(self, node):
    method visit_Delete (line 118) | def visit_Delete(self, node):
    method visit_Assign (line 126) | def visit_Assign(self, node):
    method visit_AugAssign (line 134) | def visit_AugAssign(self, node):
    method visit_AnnAssign (line 140) | def visit_AnnAssign(self, node):
    method visit_For (line 147) | def visit_For(self, node):
    method visit_AsyncFor (line 154) | def visit_AsyncFor(self, node):
    method visit_While (line 161) | def visit_While(self, node):
    method visit_If (line 167) | def visit_If(self, node):
    method visit_With (line 173) | def visit_With(self, node):
    method visit_AsyncWith (line 178) | def visit_AsyncWith(self, node):
    method visit_Match (line 183) | def visit_Match(self, node):
    method visit_Raise (line 194) | def visit_Raise(self, node):
    method visit_Try (line 198) | def visit_Try(self, node):
    method visit_Assert (line 205) | def visit_Assert(self, node):
    method visit_Import (line 209) | def visit_Import(self, node):
    method visit_ImportFrom (line 218) | def visit_ImportFrom(self, node):
    method visit_Global (line 229) | def visit_Global(self, node):
    method visit_Nonlocal (line 233) | def visit_Nonlocal(self, node):
    method visit_Expr (line 237) | def visit_Expr(self, node):
    method visit_Pass (line 241) | def visit_Pass(self, node):
    method visit_Break (line 245) | def visit_Break(self, node):
    method visit_Continue (line 249) | def visit_Continue(self, node):
    method visit_BoolOp (line 257) | def visit_BoolOp(self, node):
    method visit_NamedExpr (line 277) | def visit_NamedExpr(self, node):
    method visit_BinOp (line 285) | def visit_BinOp(self, node):
    method visit_UnaryOp (line 305) | def visit_UnaryOp(self, node):
    method visit_Lambda (line 314) | def visit_Lambda(self, node):
    method visit_IfExp (line 330) | def visit_IfExp(self, node):
    method visit_Dict (line 339) | def visit_Dict(self, node):
    method visit_Set (line 355) | def visit_Set(self, node):
    method visit_ListComp (line 364) | def visit_ListComp(self, node):
    method visit_SetComp (line 388) | def visit_SetComp(self, node):
    method visit_DictComp (line 412) | def visit_DictComp(self, node):
    method visit_GeneratorExp (line 440) | def visit_GeneratorExp(self, node):
    method visit_Await (line 464) | def visit_Await(self, node):
    method visit_Yield (line 471) | def visit_Yield(self, node):
    method visit_YieldFrom (line 478) | def visit_YieldFrom(self, node):
    method visit_Compare (line 486) | def visit_Compare(self, node):
    method visit_Call (line 508) | def visit_Call(self, node):
    method visit_FormattedValue (line 529) | def visit_FormattedValue(self, node):
    method visit_JoinedStr (line 534) | def visit_JoinedStr(self, node):
    method visit_Constant (line 538) | def visit_Constant(self, node):
    method visit_Attribute (line 542) | def visit_Attribute(self, node):
    method visit_Subscript (line 556) | def visit_Subscript(self, node):
    method visit_Starred (line 568) | def visit_Starred(self, node):
    method visit_Name (line 572) | def visit_Name(self, node):
    method visit_List (line 579) | def visit_List(self, node):
    method visit_Tuple (line 590) | def visit_Tuple(self, node):
    method visit_Slice (line 601) | def visit_Slice(self, node):
    method visit_Load (line 634) | def visit_Load(self, node):
    method visit_Store (line 638) | def visit_Store(self, node):
    method visit_Del (line 642) | def visit_Del(self, node):
    method visit_And (line 650) | def visit_And(self, node):
    method visit_Or (line 654) | def visit_Or(self, node):
    method visit_Add (line 662) | def visit_Add(self, node):
    method visit_Sub (line 666) | def visit_Sub(self, node):
    method visit_Mult (line 670) | def visit_Mult(self, node):
    method visit_MatMult (line 674) | def visit_MatMult(self, node):
    method visit_Div (line 678) | def visit_Div(self, node):
    method visit_Mod (line 682) | def visit_Mod(self, node):
    method visit_Pow (line 686) | def visit_Pow(self, node):
    method visit_LShift (line 690) | def visit_LShift(self, node):
    method visit_RShift (line 694) | def visit_RShift(self, node):
    method visit_BitOr (line 698) | def visit_BitOr(self, node):
    method visit_BitXor (line 702) | def visit_BitXor(self, node):
    method visit_BitAnd (line 706) | def visit_BitAnd(self, node):
    method visit_FloorDiv (line 710) | def visit_FloorDiv(self, node):
    method visit_Invert (line 718) | def visit_Invert(self, node):
    method visit_Not (line 722) | def visit_Not(self, node):
    method visit_UAdd (line 726) | def visit_UAdd(self, node):
    method visit_USub (line 730) | def visit_USub(self, node):
    method visit_Eq (line 738) | def visit_Eq(self, node):
    method visit_NotEq (line 742) | def visit_NotEq(self, node):
    method visit_Lt (line 746) | def visit_Lt(self, node):
    method visit_LtE (line 750) | def visit_LtE(self, node):
    method visit_Gt (line 754) | def visit_Gt(self, node):
    method visit_GtE (line 758) | def visit_GtE(self, node):
    method visit_Is (line 762) | def visit_Is(self, node):
    method visit_IsNot (line 766) | def visit_IsNot(self, node):
    method visit_In (line 770) | def visit_In(self, node):
    method visit_NotIn (line 774) | def visit_NotIn(self, node):
    method visit_ExceptionHandler (line 782) | def visit_ExceptionHandler(self, node):
    method visit_MatchValue (line 792) | def visit_MatchValue(self, node):
    method visit_MatchSingleton (line 796) | def visit_MatchSingleton(self, node):
    method visit_MatchSequence (line 800) | def visit_MatchSequence(self, node):
    method visit_MatchMapping (line 804) | def visit_MatchMapping(self, node):
    method visit_MatchClass (line 810) | def visit_MatchClass(self, node):
    method visit_MatchStar (line 817) | def visit_MatchStar(self, node):
    method visit_MatchAs (line 821) | def visit_MatchAs(self, node):
    method visit_MatchOr (line 826) | def visit_MatchOr(self, node):
    method visit_TypeIgnore (line 834) | def visit_TypeIgnore(self, node):
    method visit_comprehension (line 842) | def visit_comprehension(self, node):
    method visit_arguments (line 849) | def visit_arguments(self, node):
    method visit_arg (line 859) | def visit_arg(self, node):
    method visit_keyword (line 873) | def visit_keyword(self, node):
    method visit_alias (line 878) | def visit_alias(self, node):
    method visit_withitem (line 883) | def visit_withitem(self, node):
    method visit_match_case (line 888) | def visit_match_case(self, node):
  function _IncreasePenalty (line 895) | def _IncreasePenalty(tokens, amt):
  function _DecreasePenalty (line 902) | def _DecreasePenalty(tokens, amt):
  function _SetPenalty (line 909) | def _SetPenalty(tokens, amt):

FILE: yapf/pytree/blank_line_calculator.py
  function CalculateBlankLines (line 44) | def CalculateBlankLines(tree):
  class _BlankLineCalculator (line 56) | class _BlankLineCalculator(pytree_visitor.PyTreeVisitor):
    method __init__ (line 59) | def __init__(self):
    method Visit_simple_stmt (line 66) | def Visit_simple_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_decorator (line 71) | def Visit_decorator(self, node):  # pylint: disable=invalid-name
    method Visit_classdef (line 81) | def Visit_classdef(self, node):  # pylint: disable=invalid-name
    method Visit_funcdef (line 91) | def Visit_funcdef(self, node):  # pylint: disable=invalid-name
    method DefaultNodeVisit (line 107) | def DefaultNodeVisit(self, node):
    method _SetBlankLinesBetweenCommentAndClassFunc (line 123) | def _SetBlankLinesBetweenCommentAndClassFunc(self, node):
    method _GetNumNewlines (line 154) | def _GetNumNewlines(self, node):
    method _IsTopLevel (line 161) | def _IsTopLevel(self, node):
  function _SetNumNewlines (line 166) | def _SetNumNewlines(node, num_newlines):
  function _StartsInZerothColumn (line 171) | def _StartsInZerothColumn(node):
  function _AsyncFunction (line 176) | def _AsyncFunction(node):

FILE: yapf/pytree/comment_splicer.py
  function SpliceComments (line 31) | def SpliceComments(tree):
  function _CreateCommentsFromPrefix (line 206) | def _CreateCommentsFromPrefix(comment_prefix,
  function _FindNodeWithStandaloneLineParent (line 271) | def _FindNodeWithStandaloneLineParent(node):
  function _FindStmtParent (line 295) | def _FindStmtParent(node):
  function _FindAncestorAtIndent (line 310) | def _FindAncestorAtIndent(node, indent):
  function _AnnotateIndents (line 341) | def _AnnotateIndents(tree):

FILE: yapf/pytree/continuation_splicer.py
  function SpliceContinuations (line 27) | def SpliceContinuations(tree):

FILE: yapf/pytree/pytree_unwrapper.py
  function UnwrapPyTree (line 47) | def UnwrapPyTree(tree):
  class PyTreeUnwrapper (line 70) | class PyTreeUnwrapper(pytree_visitor.PyTreeVisitor):
    method __init__ (line 85) | def __init__(self):
    method GetLogicalLines (line 96) | def GetLogicalLines(self):
    method _StartNewLine (line 108) | def _StartNewLine(self):
    method Visit_simple_stmt (line 135) | def Visit_simple_stmt(self, node):
    method _VisitCompoundStatement (line 158) | def _VisitCompoundStatement(self, node, substatement_names):
    method Visit_if_stmt (line 182) | def Visit_if_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_while_stmt (line 187) | def Visit_while_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_for_stmt (line 192) | def Visit_for_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_try_stmt (line 197) | def Visit_try_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_except_clause (line 202) | def Visit_except_clause(self, node):  # pylint: disable=invalid-name
    method Visit_funcdef (line 207) | def Visit_funcdef(self, node):  # pylint: disable=invalid-name
    method Visit_async_funcdef (line 210) | def Visit_async_funcdef(self, node):  # pylint: disable=invalid-name
    method Visit_classdef (line 223) | def Visit_classdef(self, node):  # pylint: disable=invalid-name
    method Visit_async_stmt (line 226) | def Visit_async_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_decorator (line 239) | def Visit_decorator(self, node):  # pylint: disable=invalid-name
    method Visit_decorators (line 245) | def Visit_decorators(self, node):  # pylint: disable=invalid-name
    method Visit_decorated (line 250) | def Visit_decorated(self, node):  # pylint: disable=invalid-name
    method Visit_with_stmt (line 257) | def Visit_with_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_match_stmt (line 262) | def Visit_match_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_case_block (line 268) | def Visit_case_block(self, node):
    method Visit_suite (line 274) | def Visit_suite(self, node):  # pylint: disable=invalid-name
    method Visit_listmaker (line 281) | def Visit_listmaker(self, node):  # pylint: disable=invalid-name
    method Visit_dictsetmaker (line 285) | def Visit_dictsetmaker(self, node):  # pylint: disable=invalid-name
    method Visit_import_as_names (line 289) | def Visit_import_as_names(self, node):  # pylint: disable=invalid-name
    method Visit_testlist_gexp (line 294) | def Visit_testlist_gexp(self, node):  # pylint: disable=invalid-name
    method Visit_arglist (line 298) | def Visit_arglist(self, node):  # pylint: disable=invalid-name
    method Visit_typedargslist (line 302) | def Visit_typedargslist(self, node):  # pylint: disable=invalid-name
    method Visit_subscriptlist (line 306) | def Visit_subscriptlist(self, node):  # pylint: disable=invalid-name
    method DefaultLeafVisit (line 310) | def DefaultLeafVisit(self, leaf):
  function _MatchBrackets (line 329) | def _MatchBrackets(line):
  function _IdentifyParameterLists (line 354) | def _IdentifyParameterLists(line):
  function _AdjustSplitPenalty (line 387) | def _AdjustSplitPenalty(line):
  function _DetermineMustSplitAnnotation (line 408) | def _DetermineMustSplitAnnotation(node):
  function _ContainsComments (line 446) | def _ContainsComments(node):
  function _SetMustSplitOnFirstLeaf (line 456) | def _SetMustSplitOnFirstLeaf(node):

FILE: yapf/pytree/pytree_utils.py
  class Annotation (line 43) | class Annotation(object):
  function NodeName (line 52) | def NodeName(node):
  function FirstLeafNode (line 70) | def FirstLeafNode(node):
  function LastLeafNode (line 76) | def LastLeafNode(node):
  function ParseCodeToTree (line 93) | def ParseCodeToTree(code):
  function _WrapEndMarker (line 121) | def _WrapEndMarker(tree):
  function InsertNodesBefore (line 137) | def InsertNodesBefore(new_nodes, target):
  function InsertNodesAfter (line 152) | def InsertNodesAfter(new_nodes, target):
  function _InsertNodeAt (line 167) | def _InsertNodeAt(new_node, target, after=False):
  function CopyYapfAnnotations (line 210) | def CopyYapfAnnotations(src, dst):
  function GetNodeAnnotation (line 222) | def GetNodeAnnotation(node, annotation, default=None):
  function SetNodeAnnotation (line 237) | def SetNodeAnnotation(node, annotation, value):
  function AppendNodeAnnotation (line 248) | def AppendNodeAnnotation(node, annotation, value):
  function RemoveSubtypeAnnotation (line 261) | def RemoveSubtypeAnnotation(node, value):
  function GetOpeningBracket (line 274) | def GetOpeningBracket(node):
  function SetOpeningBracket (line 286) | def SetOpeningBracket(node, bracket):
  function DumpNodeToString (line 296) | def DumpNodeToString(node):
  function _PytreeNodeRepr (line 323) | def _PytreeNodeRepr(node):
  function IsCommentStatement (line 332) | def IsCommentStatement(node):

FILE: yapf/pytree/pytree_visitor.py
  class PyTreeVisitor (line 34) | class PyTreeVisitor(object):
    method Visit (line 57) | def Visit(self, node):
    method DefaultNodeVisit (line 69) | def DefaultNodeVisit(self, node):
    method DefaultLeafVisit (line 80) | def DefaultLeafVisit(self, leaf):
  function DumpPyTree (line 91) | def DumpPyTree(tree, target_stream=sys.stdout):
  class PyTreeDumper (line 107) | class PyTreeDumper(PyTreeVisitor):
    method __init__ (line 113) | def __init__(self, target_stream=sys.stdout):
    method _DumpString (line 123) | def _DumpString(self, s):
    method DefaultNodeVisit (line 126) | def DefaultNodeVisit(self, node):
    method DefaultLeafVisit (line 134) | def DefaultLeafVisit(self, leaf):

FILE: yapf/pytree/split_penalty.py
  function ComputeSplitPenalties (line 54) | def ComputeSplitPenalties(tree):
  class _SplitPenaltyAssigner (line 63) | class _SplitPenaltyAssigner(pytree_visitor.PyTreeVisitor):
    method Visit (line 69) | def Visit(self, node):
    method Visit_import_as_names (line 73) | def Visit_import_as_names(self, node):  # pyline: disable=invalid-name
    method Visit_classdef (line 83) | def Visit_classdef(self, node):  # pylint: disable=invalid-name
    method Visit_funcdef (line 95) | def Visit_funcdef(self, node):  # pylint: disable=invalid-name
    method Visit_lambdef (line 120) | def Visit_lambdef(self, node):  # pylint: disable=invalid-name
    method Visit_parameters (line 136) | def Visit_parameters(self, node):  # pylint: disable=invalid-name
    method Visit_arglist (line 146) | def Visit_arglist(self, node):  # pylint: disable=invalid-name
    method Visit_argument (line 165) | def Visit_argument(self, node):  # pylint: disable=invalid-name
    method Visit_tname (line 177) | def Visit_tname(self, node):  # pylint: disable=invalid-name
    method Visit_dotted_name (line 189) | def Visit_dotted_name(self, node):  # pylint: disable=invalid-name
    method Visit_dictsetmaker (line 197) | def Visit_dictsetmaker(self, node):  # pylint: disable=invalid-name
    method Visit_trailer (line 208) | def Visit_trailer(self, node):  # pylint: disable=invalid-name
    method Visit_power (line 274) | def Visit_power(self, node):  # pylint: disable=invalid-name,missing-d...
    method Visit_subscriptlist (line 344) | def Visit_subscriptlist(self, node):  # pylint: disable=invalid-name
    method Visit_subscript (line 354) | def Visit_subscript(self, node):  # pylint: disable=invalid-name
    method Visit_comp_for (line 359) | def Visit_comp_for(self, node):  # pylint: disable=invalid-name
    method Visit_old_comp_for (line 365) | def Visit_old_comp_for(self, node):  # pylint: disable=invalid-name
    method Visit_comp_if (line 369) | def Visit_comp_if(self, node):  # pylint: disable=invalid-name
    method Visit_old_comp_if (line 376) | def Visit_old_comp_if(self, node):  # pylint: disable=invalid-name
    method Visit_test (line 380) | def Visit_test(self, node):  # pylint: disable=invalid-name
    method Visit_or_test (line 385) | def Visit_or_test(self, node):  # pylint: disable=invalid-name
    method Visit_and_test (line 399) | def Visit_and_test(self, node):  # pylint: disable=invalid-name
    method Visit_not_test (line 413) | def Visit_not_test(self, node):  # pylint: disable=invalid-name
    method Visit_comparison (line 418) | def Visit_comparison(self, node):  # pylint: disable=invalid-name
    method Visit_star_expr (line 428) | def Visit_star_expr(self, node):  # pylint: disable=invalid-name
    method Visit_expr (line 433) | def Visit_expr(self, node):  # pylint: disable=invalid-name
    method Visit_xor_expr (line 439) | def Visit_xor_expr(self, node):  # pylint: disable=invalid-name
    method Visit_and_expr (line 445) | def Visit_and_expr(self, node):  # pylint: disable=invalid-name
    method Visit_shift_expr (line 451) | def Visit_shift_expr(self, node):  # pylint: disable=invalid-name
    method Visit_arith_expr (line 458) | def Visit_arith_expr(self, node):  # pylint: disable=invalid-name
    method Visit_term (line 466) | def Visit_term(self, node):  # pylint: disable=invalid-name
    method Visit_factor (line 472) | def Visit_factor(self, node):  # pyline: disable=invalid-name
    method Visit_atom (line 477) | def Visit_atom(self, node):  # pylint: disable=invalid-name
    method Visit_testlist_gexp (line 495) | def Visit_testlist_gexp(self, node):  # pylint: disable=invalid-name
  function _SetUnbreakable (line 508) | def _SetUnbreakable(node):
  function _SetStronglyConnected (line 513) | def _SetStronglyConnected(*nodes):
  function _SetExpressionPenalty (line 520) | def _SetExpressionPenalty(node, penalty):
  function _SetBitwiseOperandPenalty (line 541) | def _SetBitwiseOperandPenalty(node, op):
  function _SetExpressionOperandPenalty (line 553) | def _SetExpressionOperandPenalty(node, ops):
  function _IncreasePenalty (line 565) | def _IncreasePenalty(node, amt):
  function _RecAnnotate (line 585) | def _RecAnnotate(tree, annotate_name, annotate_value):
  function _StronglyConnectedCompOp (line 608) | def _StronglyConnectedCompOp(op):
  function _DecrementSplitPenalty (line 623) | def _DecrementSplitPenalty(node, amt):
  function _SetSplitPenalty (line 630) | def _SetSplitPenalty(node, penalty):

FILE: yapf/pytree/subtype_assigner.py
  function AssignSubtypes (line 37) | def AssignSubtypes(tree):
  class _SubtypeAssigner (line 56) | class _SubtypeAssigner(pytree_visitor.PyTreeVisitor):
    method Visit_dictsetmaker (line 62) | def Visit_dictsetmaker(self, node):  # pylint: disable=invalid-name
    method Visit_expr_stmt (line 110) | def Visit_expr_stmt(self, node):  # pylint: disable=invalid-name
    method Visit_or_test (line 118) | def Visit_or_test(self, node):  # pylint: disable=invalid-name
    method Visit_and_test (line 125) | def Visit_and_test(self, node):  # pylint: disable=invalid-name
    method Visit_not_test (line 132) | def Visit_not_test(self, node):  # pylint: disable=invalid-name
    method Visit_comparison (line 139) | def Visit_comparison(self, node):  # pylint: disable=invalid-name
    method Visit_star_expr (line 151) | def Visit_star_expr(self, node):  # pylint: disable=invalid-name
    method Visit_expr (line 159) | def Visit_expr(self, node):  # pylint: disable=invalid-name
    method Visit_xor_expr (line 166) | def Visit_xor_expr(self, node):  # pylint: disable=invalid-name
    method Visit_and_expr (line 173) | def Visit_and_expr(self, node):  # pylint: disable=invalid-name
    method Visit_shift_expr (line 180) | def Visit_shift_expr(self, node):  # pylint: disable=invalid-name
    method Visit_arith_expr (line 187) | def Visit_arith_expr(self, node):  # pylint: disable=invalid-name
    method Visit_term (line 199) | def Visit_term(self, node):  # pylint: disable=invalid-name
    method Visit_factor (line 211) | def Visit_factor(self, node):  # pylint: disable=invalid-name
    method Visit_power (line 218) | def Visit_power(self, node):  # pylint: disable=invalid-name
    method Visit_lambdef (line 225) | def Visit_lambdef(self, node):  # pylint: disable=invalid-name
    method Visit_trailer (line 230) | def Visit_trailer(self, node):  # pylint: disable=invalid-name
    method Visit_subscript (line 236) | def Visit_subscript(self, node):  # pylint: disable=invalid-name
    method Visit_sliceop (line 243) | def Visit_sliceop(self, node):  # pylint: disable=invalid-name
    method Visit_argument (line 250) | def Visit_argument(self, node):  # pylint: disable=invalid-name
    method Visit_arglist (line 255) | def Visit_arglist(self, node):  # pylint: disable=invalid-name
    method Visit_tname (line 264) | def Visit_tname(self, node):  # pylint: disable=invalid-name
    method Visit_decorator (line 269) | def Visit_decorator(self, node):  # pylint: disable=invalid-name
    method Visit_funcdef (line 277) | def Visit_funcdef(self, node):  # pylint: disable=invalid-name
    method Visit_parameters (line 287) | def Visit_parameters(self, node):  # pylint: disable=invalid-name
    method Visit_typedargslist (line 294) | def Visit_typedargslist(self, node):  # pylint: disable=invalid-name
    method Visit_varargslist (line 329) | def Visit_varargslist(self, node):  # pylint: disable=invalid-name
    method Visit_comp_for (line 341) | def Visit_comp_for(self, node):  # pylint: disable=invalid-name
    method Visit_old_comp_for (line 355) | def Visit_old_comp_for(self, node):  # pylint: disable=invalid-name
    method Visit_comp_if (line 359) | def Visit_comp_if(self, node):  # pylint: disable=invalid-name
    method Visit_old_comp_if (line 364) | def Visit_old_comp_if(self, node):  # pylint: disable=invalid-name
    method _ProcessArgLists (line 368) | def _ProcessArgLists(self, node):
  function _SetArgListSubtype (line 378) | def _SetArgListSubtype(node, node_subtype, list_subtype):
  function _AppendTokenSubtype (line 404) | def _AppendTokenSubtype(node, subtype):
  function _AppendFirstLeafTokenSubtype (line 410) | def _AppendFirstLeafTokenSubtype(node, subtype):
  function _AppendLastLeafTokenSubtype (line 418) | def _AppendLastLeafTokenSubtype(node, subtype):
  function _AppendSubtypeRec (line 426) | def _AppendSubtypeRec(node, subtype, force=True):
  function _InsertPseudoParentheses (line 435) | def _InsertPseudoParentheses(node):
  function _IsAExprOperator (line 497) | def _IsAExprOperator(node):
  function _IsMExprOperator (line 501) | def _IsMExprOperator(node):
  function _IsSimpleExpression (line 506) | def _IsSimpleExpression(node):

FILE: yapf/yapflib/errors.py
  function FormatErrorMsg (line 19) | def FormatErrorMsg(e):
  class YapfError (line 40) | class YapfError(Exception):

FILE: yapf/yapflib/file_resources.py
  function _GetExcludePatternsFromYapfIgnore (line 41) | def _GetExcludePatternsFromYapfIgnore(filename):
  function _GetExcludePatternsFromPyprojectToml (line 56) | def _GetExcludePatternsFromPyprojectToml(filename):
  function GetExcludePatternsForDir (line 72) | def GetExcludePatternsForDir(dirname):
  function GetDefaultStyleForDir (line 96) | def GetDefaultStyleForDir(dirname, default_style=style.DEFAULT_STYLE):
  function GetCommandLineFiles (line 155) | def GetCommandLineFiles(command_line_file_list, recursive, exclude):
  function WriteReformattedCode (line 160) | def WriteReformattedCode(filename,
  function LineEnding (line 182) | def LineEnding(lines):
  function _FindPythonFiles (line 195) | def _FindPythonFiles(filenames, recursive, exclude):
  function IsIgnored (line 243) | def IsIgnored(path, exclude):
  function IsPythonFile (line 253) | def IsPythonFile(filename):
  function FileEncoding (line 282) | def FileEncoding(filename):

FILE: yapf/yapflib/format_decision_state.py
  class FormatDecisionState (line 37) | class FormatDecisionState(object):
    method __init__ (line 60) | def __init__(self, line, first_indent):
    method Clone (line 82) | def Clone(self):
    method __eq__ (line 98) | def __eq__(self, other):
    method __ne__ (line 112) | def __ne__(self, other):
    method __hash__ (line 115) | def __hash__(self):
    method __repr__ (line 119) | def __repr__(self):
    method CanSplit (line 124) | def CanSplit(self, must_split):
    method MustSplit (line 168) | def MustSplit(self):
    method AddTokenToState (line 577) | def AddTokenToState(self, newline, dry_run, must_split=False):
    method _AddTokenOnCurrentLine (line 605) | def _AddTokenOnCurrentLine(self, dry_run):
    method _AddTokenOnNewline (line 643) | def _AddTokenOnNewline(self, dry_run, must_split):
    method MoveStateToNextToken (line 712) | def MoveStateToNextToken(self):
    method _CalculateComprehensionState (line 769) | def _CalculateComprehensionState(self, newline):
    method _PushParameterListState (line 837) | def _PushParameterListState(self, newline):
    method _CalculateParameterListState (line 852) | def _CalculateParameterListState(self, newline):
    method _IndentWithContinuationAlignStyle (line 936) | def _IndentWithContinuationAlignStyle(self, column):
    method _GetNewlineColumn (line 948) | def _GetNewlineColumn(self):
    method _FitsOnLine (line 1005) | def _FitsOnLine(self, start, end):
    method _EachDictEntryFitsOnOneLine (line 1012) | def _EachDictEntryFitsOnOneLine(self, opening):
    method _ArgumentListHasDictionaryEntry (line 1094) | def _ArgumentListHasDictionaryEntry(self, token):
    method _ContainerFitsOnStartLine (line 1108) | def _ContainerFitsOnStartLine(self, opening):
  function _IsCompoundStatement (line 1126) | def _IsCompoundStatement(token):
  function _IsFunctionDef (line 1137) | def _IsFunctionDef(token):
  function _IsFunctionCallWithArguments (line 1143) | def _IsFunctionCallWithArguments(token):
  function _IsArgumentToFunction (line 1154) | def _IsArgumentToFunction(token):
  function _GetOpeningBracket (line 1162) | def _GetOpeningBracket(current):
  function _LastTokenInLine (line 1178) | def _LastTokenInLine(current):
  function _IsFunctionDefinition (line 1184) | def _IsFunctionDefinition(current):
  function _IsLastScopeInLine (line 1189) | def _IsLastScopeInLine(current):
  function _IsSingleElementTuple (line 1198) | def _IsSingleElementTuple(token):
  function _ScopeHasNoCommas (line 1210) | def _ScopeHasNoCommas(token):
  class _ParenState (line 1221) | class _ParenState(object):
    method __init__ (line 1241) | def __init__(self, indent, last_space):
    method Clone (line 1248) | def Clone(self):
    method __repr__ (line 1255) | def __repr__(self):
    method __eq__ (line 1259) | def __eq__(self, other):
    method __ne__ (line 1262) | def __ne__(self, other):
    method __hash__ (line 1265) | def __hash__(self, *args, **kwargs):

FILE: yapf/yapflib/format_token.py
  function _TabbedContinuationAlignPadding (line 33) | def _TabbedContinuationAlignPadding(spaces, align_style, tab_width):
  class FormatToken (line 51) | class FormatToken(object):
    method __init__ (line 87) | def __init__(self, node, name):
    method formatted_whitespace_prefix (line 129) | def formatted_whitespace_prefix(self):
    method AddWhitespacePrefix (line 137) | def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0):
    method AdjustNewlinesBefore (line 171) | def AdjustNewlinesBefore(self, newlines_before):
    method RetainHorizontalSpacing (line 176) | def RetainHorizontalSpacing(self, first_column, depth):
    method OpensScope (line 214) | def OpensScope(self):
    method ClosesScope (line 217) | def ClosesScope(self):
    method AddSubtype (line 220) | def AddSubtype(self, subtype):
    method __repr__ (line 223) | def __repr__(self):
    method node_split_penalty (line 232) | def node_split_penalty(self):
    method is_binary_op (line 238) | def is_binary_op(self):
    method is_arithmetic_op (line 244) | def is_arithmetic_op(self):
    method is_simple_expr (line 263) | def is_simple_expr(self):
    method is_subscript_colon (line 268) | def is_subscript_colon(self):
    method is_comment (line 273) | def is_comment(self):
    method is_continuation (line 277) | def is_continuation(self):
    method is_keyword (line 282) | def is_keyword(self):
    method is_name (line 290) | def is_name(self):
    method is_number (line 294) | def is_number(self):
    method is_string (line 298) | def is_string(self):
    method is_multiline_string (line 302) | def is_multiline_string(self):
    method is_docstring (line 313) | def is_docstring(self):
    method is_pylint_comment (line 317) | def is_pylint_comment(self):
    method is_pytype_comment (line 322) | def is_pytype_comment(self):
    method is_copybara_comment (line 327) | def is_copybara_comment(self):

FILE: yapf/yapflib/identify_container.py
  function IdentifyContainers (line 28) | def IdentifyContainers(tree):
  class _IdentifyContainers (line 38) | class _IdentifyContainers(pytree_visitor.PyTreeVisitor):
    method Visit_trailer (line 41) | def Visit_trailer(self, node):  # pylint: disable=invalid-name
    method Visit_atom (line 58) | def Visit_atom(self, node):  # pylint: disable=invalid-name

FILE: yapf/yapflib/line_joiner.py
  function CanMergeMultipleLines (line 42) | def CanMergeMultipleLines(lines, last_was_merged=False):
  function _CanMergeLineIntoIfStatement (line 85) | def _CanMergeLineIntoIfStatement(lines, limit):

FILE: yapf/yapflib/logical_line.py
  class LogicalLine (line 31) | class LogicalLine(object):
    method __init__ (line 40) | def __init__(self, depth, tokens=None):
    method CalculateFormattingInformation (line 62) | def CalculateFormattingInformation(self):
    method Split (line 103) | def Split(self):
    method AppendToken (line 130) | def AppendToken(self, token):
    method first (line 138) | def first(self):
    method last (line 143) | def last(self):
    method AsCode (line 151) | def AsCode(self, indent_per_depth=2):
    method __str__ (line 170) | def __str__(self):  # pragma: no cover
    method __repr__ (line 173) | def __repr__(self):  # pragma: no cover
    method tokens (line 184) | def tokens(self):
    method lineno (line 195) | def lineno(self):
    method start (line 204) | def start(self):
    method end (line 213) | def end(self):
    method is_comment (line 222) | def is_comment(self):
    method has_semicolon (line 226) | def has_semicolon(self):
  function _IsIdNumberStringToken (line 230) | def _IsIdNumberStringToken(tok):
  function _IsUnaryOperator (line 234) | def _IsUnaryOperator(tok):
  function _HasPrecedence (line 238) | def _HasPrecedence(tok):
  function _PriorityIndicatingNoSpace (line 264) | def _PriorityIndicatingNoSpace(tok):
  function _IsSubscriptColonAndValuePair (line 272) | def _IsSubscriptColonAndValuePair(token1, token2):
  function _SpaceRequiredBetween (line 276) | def _SpaceRequiredBetween(left, right, is_line_disabled):
  function _MustBreakBefore (line 487) | def _MustBreakBefore(prev_token, cur_token):
  function _CanBreakBefore (line 503) | def _CanBreakBefore(prev_token, cur_token):
  function IsSurroundedByBrackets (line 543) | def IsSurroundedByBrackets(tok):
  function _IsDictListTupleDelimiterTok (line 574) | def _IsDictListTupleDelimiterTok(tok, is_opening):
  function _SplitPenalty (line 606) | def _SplitPenalty(prev_token, cur_token):

FILE: yapf/yapflib/object_state.py
  class ComprehensionState (line 27) | class ComprehensionState(object):
    method __init__ (line 44) | def __init__(self, expr_token):
    method HasTrivialExpr (line 50) | def HasTrivialExpr(self):
    method opening_bracket (line 55) | def opening_bracket(self):
    method closing_bracket (line 59) | def closing_bracket(self):
    method Clone (line 62) | def Clone(self):
    method __repr__ (line 69) | def __repr__(self):
    method __eq__ (line 75) | def __eq__(self, other):
    method __ne__ (line 78) | def __ne__(self, other):
    method __hash__ (line 81) | def __hash__(self, *args, **kwargs):
  class ParameterListState (line 86) | class ParameterListState(object):
    method __init__ (line 104) | def __init__(self, opening_bracket, newline, opening_column):
    method closing_bracket (line 112) | def closing_bracket(self):
    method has_typed_return (line 116) | def has_typed_return(self):
    method has_default_values (line 121) | def has_default_values(self):
    method ends_in_comma (line 126) | def ends_in_comma(self):
    method last_token (line 133) | def last_token(self):
    method LastParamFitsOnLine (line 140) | def LastParamFitsOnLine(self, indent):
    method SplitBeforeClosingBracket (line 152) | def SplitBeforeClosingBracket(self, indent):
    method Clone (line 165) | def Clone(self):
    method __repr__ (line 173) | def __repr__(self):
    method __eq__ (line 179) | def __eq__(self, other):
    method __ne__ (line 182) | def __ne__(self, other):
    method __hash__ (line 185) | def __hash__(self, *args, **kwargs):
  class Parameter (line 191) | class Parameter(object):
    method __init__ (line 200) | def __init__(self, first_token, last_token):
    method has_default_value (line 206) | def has_default_value(self):
    method Clone (line 215) | def Clone(self):
    method __repr__ (line 218) | def __repr__(self):
    method __eq__ (line 222) | def __eq__(self, other):
    method __ne__ (line 225) | def __ne__(self, other):
    method __hash__ (line 228) | def __hash__(self, *args, **kwargs):

FILE: yapf/yapflib/reformatter.py
  function Reformat (line 36) | def Reformat(llines, lines=None):
  function _RetainHorizontalSpacing (line 105) | def _RetainHorizontalSpacing(line):
  function _RetainRequiredVerticalSpacing (line 111) | def _RetainRequiredVerticalSpacing(cur_line, prev_line, lines):
  function _RetainRequiredVerticalSpacingBetweenTokens (line 127) | def _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines):
  function _RetainVerticalSpacingBeforeComments (line 164) | def _RetainVerticalSpacingBeforeComments(line):
  function _EmitLineUnformatted (line 175) | def _EmitLineUnformatted(state):
  function _LineContainsI18n (line 202) | def _LineContainsI18n(line):
  function _LineContainsPylintDisableLineTooLong (line 229) | def _LineContainsPylintDisableLineTooLong(line):
  function _LineHasContinuationMarkers (line 234) | def _LineHasContinuationMarkers(line):
  function _CanPlaceOnSingleLine (line 239) | def _CanPlaceOnSingleLine(line):
  function _AlignTrailingComments (line 269) | def _AlignTrailingComments(final_lines):
  function _FormatFinalLines (line 398) | def _FormatFinalLines(final_lines):
  class _StateNode (line 418) | class _StateNode(object):
    method __init__ (line 431) | def __init__(self, state, newline, previous):
    method __repr__ (line 436) | def __repr__(self):  # pragma: no cover
  function _AnalyzeSolutionSpace (line 453) | def _AnalyzeSolutionSpace(initial_state):
  function _AddNextStateToQueue (line 509) | def _AddNextStateToQueue(penalty, previous_node, newline, count, p_queue):
  function _ReconstructPath (line 541) | def _ReconstructPath(initial_state, current):
  function _FormatFirstToken (line 563) | def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines):
  function _IsClassOrDef (line 600) | def _IsClassOrDef(tok):
  function _CalculateNumberOfNewlines (line 607) | def _CalculateNumberOfNewlines(first_token, indent_depth, prev_line,
  function _SingleOrMergedLines (line 718) | def _SingleOrMergedLines(lines):
  function _NoBlankLinesBeforeCurrentToken (line 766) | def _NoBlankLinesBeforeCurrentToken(text, cur_token, prev_token):

FILE: yapf/yapflib/style.py
  class StyleConfigError (line 30) | class StyleConfigError(errors.YapfError):
  function Get (line 35) | def Get(setting_name):
  function GetOrDefault (line 40) | def GetOrDefault(setting_name, default_value):
  function Help (line 45) | def Help():
  function SetGlobalStyle (line 50) | def SetGlobalStyle(style):
  function CreatePEP8Style (line 476) | def CreatePEP8Style():
  function CreateGoogleStyle (line 543) | def CreateGoogleStyle():
  function CreateYapfStyle (line 562) | def CreateYapfStyle():
  function CreateFacebookStyle (line 574) | def CreateFacebookStyle():
  function _GetStyleFactory (line 608) | def _GetStyleFactory(style):
  function _ContinuationAlignStyleStringConverter (line 615) | def _ContinuationAlignStyleStringConverter(s):
  function _StringListConverter (line 627) | def _StringListConverter(s):
  function _StringSetConverter (line 632) | def _StringSetConverter(s):
  function _BoolConverter (line 639) | def _BoolConverter(s):
  function _IntListConverter (line 644) | def _IntListConverter(s):
  function _IntOrIntListConverter (line 653) | def _IntOrIntListConverter(s):
  function CreateStyleFromConfig (line 732) | def CreateStyleFromConfig(style_config):
  function _CreateConfigParserFromConfigDict (line 778) | def _CreateConfigParserFromConfigDict(config_dict):
  function _CreateConfigParserFromConfigString (line 786) | def _CreateConfigParserFromConfigString(config_string):
  function _CreateConfigParserFromConfigFile (line 803) | def _CreateConfigParserFromConfigFile(config_filename):
  function _CreateStyleFromConfigParser (line 844) | def _CreateStyleFromConfigParser(config):

FILE: yapf/yapflib/yapf_api.py
  function FormatFile (line 53) | def FormatFile(filename,
  function FormatTree (line 105) | def FormatTree(tree, style_config=None, lines=None):
  function FormatAST (line 142) | def FormatAST(ast, style_config=None, lines=None):
  function FormatCode (line 171) | def FormatCode(unformatted_source,
  function ReadFile (line 216) | def ReadFile(filename, logger=None):
  function _SplitSemicolons (line 257) | def _SplitSemicolons(lines):
  function _LineRangesToSet (line 268) | def _LineRangesToSet(line_ranges):
  function _MarkLinesToFormat (line 281) | def _MarkLinesToFormat(llines, lines):
  function _DisableYAPF (line 309) | def _DisableYAPF(line):
  function _EnableYAPF (line 316) | def _EnableYAPF(line):
  function _GetUnifiedDiff (line 323) | def _GetUnifiedDiff(before, after, filename='code'):

FILE: yapftests/blank_line_calculator_test.py
  class BasicBlankLineCalculatorTest (line 26) | class BasicBlankLineCalculatorTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 29) | def setUpClass(cls):
    method testDecorators (line 32) | def testDecorators(self):
    method testComplexDecorators (line 47) | def testComplexDecorators(self):
    method testCodeAfterFunctionsAndClasses (line 83) | def testCodeAfterFunctionsAndClasses(self):
    method testCommentSpacing (line 128) | def testCommentSpacing(self):
    method testCommentBeforeMethod (line 194) | def testCommentBeforeMethod(self):
    method testCommentsBeforeClassDefs (line 205) | def testCommentsBeforeClassDefs(self):
    method testCommentsBeforeDecorator (line 218) | def testCommentsBeforeDecorator(self):
    method testCommentsAfterDecorator (line 239) | def testCommentsAfterDecorator(self):
    method testInnerClasses (line 256) | def testInnerClasses(self):
    method testLinesOnRangeBoundary (line 280) | def testLinesOnRangeBoundary(self):
    method testLinesRangeBoundaryNotOutside (line 317) | def testLinesRangeBoundaryNotOutside(self):
    method testLinesRangeRemove (line 350) | def testLinesRangeRemove(self):
    method testLinesRangeRemoveSome (line 384) | def testLinesRangeRemoveSome(self):

FILE: yapftests/comment_splicer_test.py
  class CommentSplicerTest (line 25) | class CommentSplicerTest(yapf_test_helper.YAPFTest):
    method _AssertNodeType (line 27) | def _AssertNodeType(self, expected_type, node):
    method _AssertNodeIsComment (line 30) | def _AssertNodeIsComment(self, node, text_in_comment=None):
    method _FindNthChildNamed (line 40) | def _FindNthChildNamed(self, node, name, n=1):
    method testSimpleInline (line 47) | def testSimpleInline(self):
    method testSimpleSeparateLine (line 62) | def testSimpleSeparateLine(self):
    method testTwoLineComment (line 77) | def testTwoLineComment(self):
    method testCommentIsFirstChildInCompound (line 91) | def testCommentIsFirstChildInCompound(self):
    method testCommentIsLastChildInCompound (line 107) | def testCommentIsLastChildInCompound(self):
    method testInlineAfterSeparateLine (line 123) | def testInlineAfterSeparateLine(self):
    method testSeparateLineAfterInline (line 141) | def testSeparateLineAfterInline(self):
    method testCommentBeforeDedent (line 159) | def testCommentBeforeDedent(self):
    method testCommentBeforeDedentTwoLevel (line 174) | def testCommentBeforeDedentTwoLevel(self):
    method testCommentBeforeDedentTwoLevelImproperlyIndented (line 191) | def testCommentBeforeDedentTwoLevelImproperlyIndented(self):
    method testCommentBeforeDedentThreeLevel (line 211) | def testCommentBeforeDedentThreeLevel(self):
    method testCommentsInClass (line 238) | def testCommentsInClass(self):
    method testMultipleBlockComments (line 260) | def testMultipleBlockComments(self):
    method testCommentsOnDedents (line 279) | def testCommentsOnDedents(self):
    method testExprComments (line 303) | def testExprComments(self):
    method testMultipleCommentsInOneExpr (line 315) | def testMultipleCommentsInOneExpr(self):

FILE: yapftests/file_resources_test.py
  function _restore_working_dir (line 33) | def _restore_working_dir():
  function _exists_mocked_in_module (line 42) | def _exists_mocked_in_module(module, mock_implementation):
  class GetExcludePatternsForDir (line 51) | class GetExcludePatternsForDir(yapf_test_helper.YAPFTest):
    method setUp (line 53) | def setUp(self):  # pylint: disable=g-missing-super-call
    method tearDown (line 56) | def tearDown(self):  # pylint: disable=g-missing-super-call
    method test_get_exclude_file_patterns_from_yapfignore (line 59) | def test_get_exclude_file_patterns_from_yapfignore(self):
    method test_get_exclude_file_patterns_from_yapfignore_with_wrong_syntax (line 69) | def test_get_exclude_file_patterns_from_yapfignore_with_wrong_syntax(s...
    method test_get_exclude_file_patterns_from_pyproject (line 78) | def test_get_exclude_file_patterns_from_pyproject(self):
    method test_get_exclude_file_patterns_from_pyproject_no_ignore_section (line 91) | def test_get_exclude_file_patterns_from_pyproject_no_ignore_section(se...
    method test_get_exclude_file_patterns_from_pyproject_ignore_section_empty (line 100) | def test_get_exclude_file_patterns_from_pyproject_ignore_section_empty...
    method test_get_exclude_file_patterns_with_no_config_files (line 110) | def test_get_exclude_file_patterns_with_no_config_files(self):
  class GetDefaultStyleForDirTest (line 118) | class GetDefaultStyleForDirTest(yapf_test_helper.YAPFTest):
    method setUp (line 120) | def setUp(self):  # pylint: disable=g-missing-super-call
    method tearDown (line 123) | def tearDown(self):  # pylint: disable=g-missing-super-call
    method test_no_local_style (line 126) | def test_no_local_style(self):
    method test_no_local_style_custom_default (line 131) | def test_no_local_style_custom_default(self):
    method test_with_local_style (line 137) | def test_with_local_style(self):
    method test_setup_config (line 150) | def test_setup_config(self):
    method test_pyproject_toml (line 165) | def test_pyproject_toml(self):
    method test_local_style_at_root (line 179) | def test_local_style_at_root(self):
  function _touch_files (line 202) | def _touch_files(filenames):
  class GetCommandLineFilesTest (line 207) | class GetCommandLineFilesTest(yapf_test_helper.YAPFTest):
    method setUp (line 209) | def setUp(self):  # pylint: disable=g-missing-super-call
    method tearDown (line 213) | def tearDown(self):  # pylint: disable=g-missing-super-call
    method _make_test_dir (line 217) | def _make_test_dir(self, name):
    method test_find_files_not_dirs (line 222) | def test_find_files_not_dirs(self):
    method test_nonrecursive_find_in_dir (line 238) | def test_nonrecursive_find_in_dir(self):
    method test_recursive_find_in_dir (line 252) | def test_recursive_find_in_dir(self):
    method test_recursive_find_in_dir_with_exclude (line 269) | def test_recursive_find_in_dir_with_exclude(self):
    method test_find_with_excluded_hidden_dirs (line 290) | def test_find_with_excluded_hidden_dirs(self):
    method test_find_with_excluded_hidden_dirs_relative (line 312) | def test_find_with_excluded_hidden_dirs_relative(self):
    method test_find_with_excluded_dirs (line 354) | def test_find_with_excluded_dirs(self):
    method test_find_with_excluded_current_dir (line 389) | def test_find_with_excluded_current_dir(self):
  class IsPythonFileTest (line 394) | class IsPythonFileTest(yapf_test_helper.YAPFTest):
    method setUp (line 396) | def setUp(self):  # pylint: disable=g-missing-super-call
    method tearDown (line 399) | def tearDown(self):  # pylint: disable=g-missing-super-call
    method test_with_py_extension (line 402) | def test_with_py_extension(self):
    method test_empty_without_py_extension (line 406) | def test_empty_without_py_extension(self):
    method test_python_shebang (line 412) | def test_python_shebang(self):
    method test_with_latin_encoding (line 423) | def test_with_latin_encoding(self):
    method test_with_invalid_encoding (line 429) | def test_with_invalid_encoding(self):
  class IsIgnoredTest (line 437) | class IsIgnoredTest(yapf_test_helper.YAPFTest):
    method test_root_path (line 439) | def test_root_path(self):
    method test_sub_path (line 443) | def test_sub_path(self):
    method test_trailing_slash (line 448) | def test_trailing_slash(self):
  class BufferedByteStream (line 453) | class BufferedByteStream(object):
    method __init__ (line 455) | def __init__(self):
    method getvalue (line 458) | def getvalue(self):  # pylint: disable=invalid-name
    method buffer (line 462) | def buffer(self):
  class WriteReformattedCodeTest (line 466) | class WriteReformattedCodeTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 469) | def setUpClass(cls):  # pylint: disable=g-missing-super-call
    method tearDownClass (line 473) | def tearDownClass(cls):  # pylint: disable=g-missing-super-call
    method test_write_to_file (line 476) | def test_write_to_file(self):
    method test_write_to_stdout (line 486) | def test_write_to_stdout(self):
    method test_write_encoded_to_stdout (line 494) | def test_write_encoded_to_stdout(self):
  class LineEndingTest (line 503) | class LineEndingTest(yapf_test_helper.YAPFTest):
    method test_line_ending_linefeed (line 505) | def test_line_ending_linefeed(self):
    method test_line_ending_carriage_return (line 510) | def test_line_ending_carriage_return(self):
    method test_line_ending_combo (line 515) | def test_line_ending_combo(self):
    method test_line_ending_weighted (line 520) | def test_line_ending_weighted(self):
    method test_line_ending_empty (line 530) | def test_line_ending_empty(self):
    method test_line_ending_no_newline (line 535) | def test_line_ending_no_newline(self):
    method test_line_ending_tie (line 540) | def test_line_ending_tie(self):

FILE: yapftests/format_decision_state_test.py
  class FormatDecisionStateTest (line 27) | class FormatDecisionStateTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 30) | def setUpClass(cls):
    method testSimpleFunctionDefWithNoSplitting (line 33) | def testSimpleFunctionDefWithNoSplitting(self):
    method testSimpleFunctionDefWithSplitting (line 87) | def testSimpleFunctionDefWithSplitting(self):
  function _FilterLine (line 136) | def _FilterLine(lline):

FILE: yapftests/format_token_test.py
  class TabbedContinuationAlignPaddingTest (line 26) | class TabbedContinuationAlignPaddingTest(yapf_test_helper.YAPFTest):
    method testSpace (line 28) | def testSpace(self):
    method testFixed (line 40) | def testFixed(self):
    method testVAlignRight (line 52) | def testVAlignRight(self):
  class FormatTokenTest (line 68) | class FormatTokenTest(yapf_test_helper.YAPFTest):
    method testSimple (line 70) | def testSimple(self):
    method testIsMultilineString (line 85) | def testIsMultilineString(self):

FILE: yapftests/line_joiner_test.py
  class LineJoinerTest (line 25) | class LineJoinerTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 28) | def setUpClass(cls):
    method _CheckLineJoining (line 31) | def _CheckLineJoining(self, code, join_lines):
    method testSimpleSingleLineStatement (line 41) | def testSimpleSingleLineStatement(self):
    method testSimpleMultipleLineStatement (line 47) | def testSimpleMultipleLineStatement(self):
    method testSimpleMultipleLineComplexStatement (line 54) | def testSimpleMultipleLineComplexStatement(self):
    method testSimpleMultipleLineStatementWithComment (line 62) | def testSimpleMultipleLineStatementWithComment(self):
    method testSimpleMultipleLineStatementWithLargeIndent (line 68) | def testSimpleMultipleLineStatementWithLargeIndent(self):
    method testOverColumnLimit (line 74) | def testOverColumnLimit(self):

FILE: yapftests/logical_line_test.py
  class LogicalLineBasicTest (line 29) | class LogicalLineBasicTest(yapf_test_helper.YAPFTest):
    method testConstruction (line 31) | def testConstruction(self):
    method testFirstLast (line 38) | def testFirstLast(self):
    method testAsCode (line 47) | def testAsCode(self):
    method testAppendToken (line 54) | def testAppendToken(self):
  class LogicalLineFormattingInformationTest (line 61) | class LogicalLineFormattingInformationTest(yapf_test_helper.YAPFTest):
    method testFuncDef (line 63) | def testFuncDef(self):
  function _MakeFormatTokenLeaf (line 81) | def _MakeFormatTokenLeaf(token_type, token_value, name):
  function _MakeFormatTokenList (line 85) | def _MakeFormatTokenList(token_type_values):

FILE: yapftests/main_test.py
  class IO (line 27) | class IO(object):
    class Buffer (line 34) | class Buffer(object):
      method __init__ (line 36) | def __init__(self):
      method write (line 39) | def write(self, s):
      method getvalue (line 44) | def getvalue(self):
    method __init__ (line 47) | def __init__(self):
    method write (line 50) | def write(self, s):
    method getvalue (line 53) | def getvalue(self):
  function captured_output (line 58) | def captured_output():
  function patched_input (line 69) | def patched_input(code):
  class RunMainTest (line 88) | class RunMainTest(yapf_test_helper.YAPFTest):
    method testShouldHandleYapfError (line 90) | def testShouldHandleYapfError(self):
  class MainTest (line 101) | class MainTest(yapf_test_helper.YAPFTest):
    method testNoPythonFilesMatched (line 103) | def testNoPythonFilesMatched(self):
    method testEchoInput (line 108) | def testEchoInput(self):
    method testEchoInputWithStyle (line 116) | def testEchoInputWithStyle(self):
    method testEchoBadInput (line 125) | def testEchoBadInput(self):
    method testHelp (line 132) | def testHelp(self):

FILE: yapftests/pytree_unwrapper_test.py
  class PytreeUnwrapperTest (line 24) | class PytreeUnwrapperTest(yapf_test_helper.YAPFTest):
    method _CheckLogicalLines (line 26) | def _CheckLogicalLines(self, llines, list_of_expected):
    method testSimpleFileScope (line 45) | def testSimpleFileScope(self):
    method testSimpleMultilineStatement (line 58) | def testSimpleMultilineStatement(self):
    method testFileScopeWithInlineComment (line 68) | def testFileScopeWithInlineComment(self):
    method testSimpleIf (line 79) | def testSimpleIf(self):
    method testSimpleIfWithComments (line 92) | def testSimpleIfWithComments(self):
    method testIfWithCommentsInside (line 107) | def testIfWithCommentsInside(self):
    method testIfElifElse (line 124) | def testIfElifElse(self):
    method testNestedCompoundTwoLevel (line 145) | def testNestedCompoundTwoLevel(self):
    method testSimpleWhile (line 164) | def testSimpleWhile(self):
    method testSimpleTry (line 177) | def testSimpleTry(self):
    method testSimpleFuncdef (line 204) | def testSimpleFuncdef(self):
    method testTwoFuncDefs (line 217) | def testTwoFuncDefs(self):
    method testSimpleClassDef (line 237) | def testSimpleClassDef(self):
    method testSingleLineStmtInFunc (line 250) | def testSingleLineStmtInFunc(self):
    method testMultipleComments (line 260) | def testMultipleComments(self):
    method testSplitListWithComment (line 276) | def testSplitListWithComment(self):
  class MatchBracketsTest (line 290) | class MatchBracketsTest(yapf_test_helper.YAPFTest):
    method _CheckMatchingBrackets (line 292) | def _CheckMatchingBrackets(self, llines, list_of_expected):
    method testFunctionDef (line 319) | def testFunctionDef(self):
    method testDecorator (line 330) | def testDecorator(self):
    method testClassDef (line 343) | def testClassDef(self):

FILE: yapftests/pytree_utils_test.py
  class NodeNameTest (line 38) | class NodeNameTest(yapf_test_helper.YAPFTest):
    method testNodeNameForLeaf (line 40) | def testNodeNameForLeaf(self):
    method testNodeNameForNode (line 44) | def testNodeNameForNode(self):
  class ParseCodeToTreeTest (line 50) | class ParseCodeToTreeTest(yapf_test_helper.YAPFTest):
    method testParseCodeToTree (line 52) | def testParseCodeToTree(self):
    method testPrintFunctionToTree (line 60) | def testPrintFunctionToTree(self):
    method testPrintStatementToTree (line 67) | def testPrintStatementToTree(self):
    method testClassNotLocal (line 71) | def testClassNotLocal(self):
  class InsertNodesBeforeAfterTest (line 76) | class InsertNodesBeforeAfterTest(yapf_test_helper.YAPFTest):
    method _BuildSimpleTree (line 78) | def _BuildSimpleTree(self):
    method _MakeNewNodeRPAR (line 95) | def _MakeNewNodeRPAR(self):
    method setUp (line 98) | def setUp(self):
    method testInsertNodesBefore (line 101) | def testInsertNodesBefore(self):
    method testInsertNodesBeforeFirstChild (line 111) | def testInsertNodesBeforeFirstChild(self):
    method testInsertNodesAfter (line 121) | def testInsertNodesAfter(self):
    method testInsertNodesAfterLastChild (line 131) | def testInsertNodesAfterLastChild(self):
    method testInsertNodesWhichHasParent (line 141) | def testInsertNodesWhichHasParent(self):
  class AnnotationsTest (line 148) | class AnnotationsTest(yapf_test_helper.YAPFTest):
    method setUp (line 150) | def setUp(self):
    method testGetWhenNone (line 155) | def testGetWhenNone(self):
    method testSetWhenNone (line 158) | def testSetWhenNone(self):
    method testSetAgain (line 162) | def testSetAgain(self):
    method testMultiple (line 168) | def testMultiple(self):
    method testSubtype (line 183) | def testSubtype(self):
    method testSetOnNode (line 197) | def testSetOnNode(self):

FILE: yapftests/pytree_visitor_test.py
  class _NodeNameCollector (line 25) | class _NodeNameCollector(pytree_visitor.PyTreeVisitor):
    method __init__ (line 35) | def __init__(self):
    method DefaultNodeVisit (line 39) | def DefaultNodeVisit(self, node):
    method DefaultLeafVisit (line 43) | def DefaultLeafVisit(self, leaf):
    method Visit_NAME (line 46) | def Visit_NAME(self, leaf):
  class PytreeVisitorTest (line 63) | class PytreeVisitorTest(yapf_test_helper.YAPFTest):
    method testCollectAllNodeNamesSimpleCode (line 65) | def testCollectAllNodeNamesSimpleCode(self):
    method testCollectAllNodeNamesNestedCode (line 80) | def testCollectAllNodeNamesNestedCode(self):
    method testDumper (line 97) | def testDumper(self):
    method testDumpPyTree (line 109) | def testDumpPyTree(self):

FILE: yapftests/reformatter_basic_test.py
  class BasicReformatterTest (line 26) | class BasicReformatterTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 29) | def setUpClass(cls):
    method testSplittingAllArgs (line 32) | def testSplittingAllArgs(self):
    method testSplittingTopLevelAllArgs (line 133) | def testSplittingTopLevelAllArgs(self):
    method testSimpleFunctionsWithTrailingComments (line 319) | def testSimpleFunctionsWithTrailingComments(self):
    method testParamListWithTrailingComments (line 348) | def testParamListWithTrailingComments(self):
    method testBlankLinesBetweenTopLevelImportsAndVariables (line 371) | def testBlankLinesBetweenTopLevelImportsAndVariables(self):
    method testBlankLinesAtEndOfFile (line 460) | def testBlankLinesAtEndOfFile(self):
    method testIndentBlankLines (line 487) | def testIndentBlankLines(self):
    method testMultipleUgliness (line 526) | def testMultipleUgliness(self):
    method testComments (line 566) | def testComments(self):
    method testSingleComment (line 619) | def testSingleComment(self):
    method testCommentsWithTrailingSpaces (line 626) | def testCommentsWithTrailingSpaces(self):
    method testCommentsInDataLiteral (line 636) | def testCommentsInDataLiteral(self):
    method testEndingWhitespaceAfterSimpleStatement (line 653) | def testEndingWhitespaceAfterSimpleStatement(self):
    method testDocstrings (line 662) | def testDocstrings(self):
    method testDocstringAndMultilineComment (line 700) | def testDocstringAndMultilineComment(self):
    method testMultilineDocstringAndMultilineComment (line 735) | def testMultilineDocstringAndMultilineComment(self):
    method testTupleCommaBeforeLastParen (line 788) | def testTupleCommaBeforeLastParen(self):
    method testNoBreakOutsideOfBracket (line 798) | def testNoBreakOutsideOfBracket(self):
    method testBlankLinesBeforeDecorators (line 814) | def testBlankLinesBeforeDecorators(self):
    method testCommentBetweenDecorators (line 835) | def testCommentBetweenDecorators(self):
    method testListComprehension (line 853) | def testListComprehension(self):
    method testListComprehensionPreferOneLine (line 866) | def testListComprehensionPreferOneLine(self):
    method testListComprehensionPreferOneLineOverArithmeticSplit (line 883) | def testListComprehensionPreferOneLineOverArithmeticSplit(self):
    method testListComprehensionPreferThreeLinesForLineWrap (line 897) | def testListComprehensionPreferThreeLinesForLineWrap(self):
    method testListComprehensionPreferNoBreakForTrivialExpression (line 916) | def testListComprehensionPreferNoBreakForTrivialExpression(self):
    method testOpeningAndClosingBrackets (line 934) | def testOpeningAndClosingBrackets(self):
    method testSingleLineFunctions (line 952) | def testSingleLineFunctions(self):
    method testNoQueueSeletionInMiddleOfLine (line 963) | def testNoQueueSeletionInMiddleOfLine(self):
    method testNoSpacesBetweenSubscriptsAndCalls (line 977) | def testNoSpacesBetweenSubscriptsAndCalls(self):
    method testNoSpacesBetweenOpeningBracketAndStartingOperator (line 987) | def testNoSpacesBetweenOpeningBracketAndStartingOperator(self):
    method testMultilineCommentReformatted (line 1010) | def testMultilineCommentReformatted(self):
    method testDictionaryMakerFormatting (line 1026) | def testDictionaryMakerFormatting(self):
    method testSimpleMultilineCode (line 1051) | def testSimpleMultilineCode(self):
    method testMultilineComment (line 1069) | def testMultilineComment(self):
    method testSpaceBetweenStringAndParentheses (line 1082) | def testSpaceBetweenStringAndParentheses(self):
    method testMultilineString (line 1089) | def testMultilineString(self):
    method testSimpleMultilineWithComments (line 1125) | def testSimpleMultilineWithComments(self):
    method testMatchingParenSplittingMatching (line 1137) | def testMatchingParenSplittingMatching(self):
    method testContinuationIndent (line 1151) | def testContinuationIndent(self):
    method testTrailingCommaAndBracket (line 1177) | def testTrailingCommaAndBracket(self):
    method testI18n (line 1195) | def testI18n(self):
    method testI18nCommentsInDataLiteral (line 1208) | def testI18nCommentsInDataLiteral(self):
    method testClosingBracketIndent (line 1222) | def testClosingBracketIndent(self):
    method testClosingBracketsInlinedInCall (line 1235) | def testClosingBracketsInlinedInCall(self):
    method testLineWrapInForExpression (line 1267) | def testLineWrapInForExpression(self):
    method testFunctionCallContinuationLine (line 1280) | def testFunctionCallContinuationLine(self):
    method testI18nNonFormatting (line 1294) | def testI18nNonFormatting(self):
    method testNoSpaceBetweenUnaryOpAndOpeningParen (line 1306) | def testNoSpaceBetweenUnaryOpAndOpeningParen(self):
    method testCommentBeforeFuncDef (line 1314) | def testCommentBeforeFuncDef(self):
    method testExcessLineCountWithDefaultKeywords (line 1332) | def testExcessLineCountWithDefaultKeywords(self):
    method testSpaceAfterNotOperator (line 1357) | def testSpaceAfterNotOperator(self):
    method testNoPenaltySplitting (line 1365) | def testNoPenaltySplitting(self):
    method testExpressionPenalties (line 1378) | def testExpressionPenalties(self):
    method testLineDepthOfSingleLineStatement (line 1389) | def testLineDepthOfSingleLineStatement(self):
    method testSplitListWithTerminatingComma (line 1412) | def testSplitListWithTerminatingComma(self):
    method testSplitListWithInterspersedComments (line 1435) | def testSplitListWithInterspersedComments(self):
    method testRelativeImportStatements (line 1454) | def testRelativeImportStatements(self):
    method testSingleLineList (line 1461) | def testSingleLineList(self):
    method testBlankLinesBeforeFunctionsNotInColumnZero (line 1476) | def testBlankLinesBeforeFunctionsNotInColumnZero(self):
    method testNoKeywordArgumentBreakage (line 1510) | def testNoKeywordArgumentBreakage(self):
    method testTrailerOnSingleLine (line 1522) | def testTrailerOnSingleLine(self):
    method testIfConditionalParens (line 1532) | def testIfConditionalParens(self):
    method testContinuationMarkers (line 1545) | def testContinuationMarkers(self):
    method testCommentsWithContinuationMarkers (line 1571) | def testCommentsWithContinuationMarkers(self):
    method testMultipleContinuationMarkers (line 1582) | def testMultipleContinuationMarkers(self):
    method testContinuationMarkerAfterStringWithContinuation (line 1591) | def testContinuationMarkerAfterStringWithContinuation(self):
    method testEmptyContainers (line 1600) | def testEmptyContainers(self):
    method testSplitStringsIfSurroundedByParens (line 1610) | def testSplitStringsIfSurroundedByParens(self):
    method testMultilineShebang (line 1633) | def testMultilineShebang(self):
    method testNoSplittingAroundTermOperators (line 1653) | def testNoSplittingAroundTermOperators(self):
    method testNoSplittingAroundCompOperators (line 1661) | def testNoSplittingAroundCompOperators(self):
    method testNoSplittingWithinSubscriptList (line 1691) | def testNoSplittingWithinSubscriptList(self):
    method testExcessCharacters (line 1701) | def testExcessCharacters(self):
    method testDictSetGenerator (line 1731) | def testDictSetGenerator(self):
    method testUnaryOpInDictionaryValue (line 1754) | def testUnaryOpInDictionaryValue(self):
    method testUnaryNotOperator (line 1765) | def testUnaryNotOperator(self):
    method testRelaxArraySubscriptAffinity (line 1777) | def testRelaxArraySubscriptAffinity(self):
    method testFunctionCallInDict (line 1793) | def testFunctionCallInDict(self):
    method testFunctionCallInNestedDict (line 1800) | def testFunctionCallInNestedDict(self):
    method testUnbreakableNot (line 1807) | def testUnbreakableNot(self):
    method testSplitListWithComment (line 1816) | def testSplitListWithComment(self):
    method testOverColumnLimit (line 1827) | def testOverColumnLimit(self):
    method testEndingComment (line 1854) | def testEndingComment(self):
    method testContinuationSpaceRetention (line 1864) | def testContinuationSpaceRetention(self):
    method testIfExpressionWithFunctionCall (line 1875) | def testIfExpressionWithFunctionCall(self):
    method testUnformattedAfterMultilineString (line 1887) | def testUnformattedAfterMultilineString(self):
    method testNoSpacesAroundKeywordDefaultValues (line 1898) | def testNoSpacesAroundKeywordDefaultValues(self):
    method testNoSplittingBeforeEndingSubscriptBracket (line 1909) | def testNoSplittingBeforeEndingSubscriptBracket(self):
    method testNoSplittingOnSingleArgument (line 1924) | def testNoSplittingOnSingleArgument(self):
    method testSplittingArraysSensibly (line 1946) | def testSplittingArraysSensibly(self):
    method testComprehensionForAndIf (line 1964) | def testComprehensionForAndIf(self):
    method testFunctionCallArguments (line 1981) | def testFunctionCallArguments(self):
    method testBinaryOperators (line 2006) | def testBinaryOperators(self):
    method testContiguousList (line 2030) | def testContiguousList(self):
    method testArgsAndKwargsFormatting (line 2038) | def testArgsAndKwargsFormatting(self):
    method testCommentColumnLimitOverflow (line 2060) | def testCommentColumnLimitOverflow(self):
    method testMultilineLambdas (line 2073) | def testMultilineLambdas(self):
    method testMultilineDictionaryKeys (line 2108) | def testMultilineDictionaryKeys(self):
    method testStableDictionaryFormatting (line 2141) | def testStableDictionaryFormatting(self):
    method testStableInlinedDictionaryFormatting (line 2173) | def testStableInlinedDictionaryFormatting(self):
    method testDontSplitKeywordValueArguments (line 2200) | def testDontSplitKeywordValueArguments(self):
    method testDontAddBlankLineAfterMultilineString (line 2214) | def testDontAddBlankLineAfterMultilineString(self):
    method testFormattingListComprehensions (line 2224) | def testFormattingListComprehensions(self):
    method testNoSplittingWhenBinPacking (line 2238) | def testNoSplittingWhenBinPacking(self):
    method testNotSplittingAfterSubscript (line 2271) | def testNotSplittingAfterSubscript(self):
    method testSplittingOneArgumentList (line 2285) | def testSplittingOneArgumentList(self):
    method testSplittingBeforeFirstElementListArgument (line 2308) | def testSplittingBeforeFirstElementListArgument(self):
    method testSplittingArgumentsTerminatedByComma (line 2337) | def testSplittingArgumentsTerminatedByComma(self):
    method testImportAsList (line 2406) | def testImportAsList(self):
    method testDictionaryValuesOnOwnLines (line 2415) | def testDictionaryValuesOnOwnLines(self):
    method testDictionaryOnOwnLine (line 2467) | def testDictionaryOnOwnLine(self):
    method testNestedListsInDictionary (line 2498) | def testNestedListsInDictionary(self):
    method testNestedDictionary (line 2565) | def testNestedDictionary(self):
    method testDictionaryElementsOnOneLine (line 2593) | def testDictionaryElementsOnOneLine(self):
    method testNotInParams (line 2613) | def testNotInParams(self):
    method testNamedAssignNotAtEndOfLine (line 2624) | def testNamedAssignNotAtEndOfLine(self):
    method testBlankLineBeforeClassDocstring (line 2642) | def testBlankLineBeforeClassDocstring(self):
    method testBlankLineBeforeModuleDocstring (line 2702) | def testBlankLineBeforeModuleDocstring(self):
    method testTupleCohesion (line 2757) | def testTupleCohesion(self):
    method testSubscriptExpression (line 2772) | def testSubscriptExpression(self):
    method testSubscriptExpressionTerminatedByComma (line 2779) | def testSubscriptExpressionTerminatedByComma(self):
    method testListWithFunctionCalls (line 2792) | def testListWithFunctionCalls(self):
    method testEllipses (line 2819) | def testEllipses(self):
    method testPseudoParens (line 2831) | def testPseudoParens(self):
    method testSplittingBeforeFirstArgumentOnFunctionCall (line 2849) | def testSplittingBeforeFirstArgumentOnFunctionCall(self):
    method testSplittingBeforeFirstArgumentOnFunctionDefinition (line 2871) | def testSplittingBeforeFirstArgumentOnFunctionDefinition(self):
    method testSplittingBeforeFirstArgumentOnCompoundStatement (line 2895) | def testSplittingBeforeFirstArgumentOnCompoundStatement(self):
    method testCoalesceBracketsOnDict (line 2921) | def testCoalesceBracketsOnDict(self):
    method testSplitAfterComment (line 2957) | def testSplitAfterComment(self):
    method testDisableEndingCommaHeuristic (line 2977) | def testDisableEndingCommaHeuristic(self):
    method testDedentClosingBracketsWithTypeAnnotationExceedingLineLength (line 2992) | def testDedentClosingBracketsWithTypeAnnotationExceedingLineLength(self):
    method testIndentClosingBracketsWithTypeAnnotationExceedingLineLength (line 3025) | def testIndentClosingBracketsWithTypeAnnotationExceedingLineLength(self):
    method testIndentClosingBracketsInFunctionCall (line 3058) | def testIndentClosingBracketsInFunctionCall(self):
    method testIndentClosingBracketsInTuple (line 3093) | def testIndentClosingBracketsInTuple(self):
    method testIndentClosingBracketsInList (line 3128) | def testIndentClosingBracketsInList(self):
    method testIndentClosingBracketsInDict (line 3163) | def testIndentClosingBracketsInDict(self):
    method testMultipleDictionariesInList (line 3204) | def testMultipleDictionariesInList(self):
    method testForceMultilineDict_True (line 3257) | def testForceMultilineDict_True(self):
    method testForceMultilineDict_False (line 3281) | def testForceMultilineDict_False(self):
    method testWalrus (line 3296) | def testWalrus(self):
    method testStructuredPatternMatching (line 3308) | def testStructuredPatternMatching(self):
    method testParenthesizedContextManagers (line 3326) | def testParenthesizedContextManagers(self):

FILE: yapftests/reformatter_buganizer_test.py
  class BuganizerFixes (line 25) | class BuganizerFixes(yapf_test_helper.YAPFTest):
    method setUpClass (line 28) | def setUpClass(cls):
    method testB137580392 (line 31) | def testB137580392(self):
    method testB73279849 (line 41) | def testB73279849(self):
    method testB122455211 (line 55) | def testB122455211(self):
    method testB119300344 (line 68) | def testB119300344(self):
    method testB132886019 (line 79) | def testB132886019(self):
    method testB26521719 (line 92) | def testB26521719(self):
    method testB122541552 (line 103) | def testB122541552(self):
    method testB124415889 (line 116) | def testB124415889(self):
    method testB73166511 (line 139) | def testB73166511(self):
    method testB118624921 (line 149) | def testB118624921(self):
    method testB35417079 (line 162) | def testB35417079(self):
    method testB120047670 (line 177) | def testB120047670(self):
    method testB120245013 (line 201) | def testB120245013(self):
    method testB117841880 (line 219) | def testB117841880(self):
    method testB111764402 (line 236) | def testB111764402(self):
    method testB116825060 (line 250) | def testB116825060(self):
    method testB112711217 (line 258) | def testB112711217(self):
    method testB112867548 (line 267) | def testB112867548(self):
    method testB112651423 (line 289) | def testB112651423(self):
    method testB80484938 (line 308) | def testB80484938(self):
    method testB120771563 (line 351) | def testB120771563(self):
    method testB79462249 (line 378) | def testB79462249(self):
    method testB113210278 (line 400) | def testB113210278(self):
    method testB77923341 (line 416) | def testB77923341(self):
    method testB77329955 (line 426) | def testB77329955(self):
    method testB65197969 (line 444) | def testB65197969(self):
    method testB65546221 (line 463) | def testB65546221(self):
    method testB30500455 (line 490) | def testB30500455(self):
    method testB38343525 (line 507) | def testB38343525(self):
    method testB37099651 (line 519) | def testB37099651(self):
    method testB33228502 (line 540) | def testB33228502(self):
    method testB30394228 (line 578) | def testB30394228(self):
    method testB65246454 (line 591) | def testB65246454(self):
    method testB67935450 (line 611) | def testB67935450(self):
    method testB66011084 (line 652) | def testB66011084(self):
    method testB67455376 (line 684) | def testB67455376(self):
    method testB35210351 (line 695) | def testB35210351(self):
    method testB34774905 (line 725) | def testB34774905(self):
    method testB65176185 (line 754) | def testB65176185(self):
    method testB35210166 (line 761) | def testB35210166(self):
    method testB32167774 (line 782) | def testB32167774(self):
    method testB66912275 (line 809) | def testB66912275(self):
    method testB67312284 (line 833) | def testB67312284(self):
    method testB65241516 (line 843) | def testB65241516(self):
    method testB37460004 (line 856) | def testB37460004(self):
    method testB36806207 (line 864) | def testB36806207(self):
    method testB36215507 (line 883) | def testB36215507(self):
    method testB35212469 (line 897) | def testB35212469(self):
    method testB31063453 (line 919) | def testB31063453(self):
    method testB35021894 (line 934) | def testB35021894(self):
    method testB34682902 (line 961) | def testB34682902(self):
    method testB33842726 (line 972) | def testB33842726(self):
    method testB32931780 (line 988) | def testB32931780(self):
    method testB33047408 (line 1050) | def testB33047408(self):
    method testB32714745 (line 1064) | def testB32714745(self):
    method testB32737279 (line 1094) | def testB32737279(self):
    method testB32570937 (line 1111) | def testB32570937(self):
    method testB31937033 (line 1122) | def testB31937033(self):
    method testB31911533 (line 1132) | def testB31911533(self):
    method testB31847238 (line 1148) | def testB31847238(self):
    method testB30760569 (line 1173) | def testB30760569(self):
    method testB26034238 (line 1187) | def testB26034238(self):
    method testB30536435 (line 1205) | def testB30536435(self):
    method testB30442148 (line 1226) | def testB30442148(self):
    method testB26868213 (line 1240) | def testB26868213(self):
    method testB30173198 (line 1276) | def testB30173198(self):
    method testB29908765 (line 1287) | def testB29908765(self):
    method testB30087362 (line 1298) | def testB30087362(self):
    method testB30087363 (line 1311) | def testB30087363(self):
    method testB29093579 (line 1323) | def testB29093579(self):
    method testB26382315 (line 1339) | def testB26382315(self):
    method testB27616132 (line 1351) | def testB27616132(self):
    method testB27590179 (line 1374) | def testB27590179(self):
    method testB27266946 (line 1398) | def testB27266946(self):
    method testB25505359 (line 1412) | def testB25505359(self):
    method testB25324261 (line 1427) | def testB25324261(self):
    method testB25136704 (line 1436) | def testB25136704(self):
    method testB25165602 (line 1448) | def testB25165602(self):
    method testB25157123 (line 1456) | def testB25157123(self):
    method testB25136820 (line 1465) | def testB25136820(self):
    method testB25131481 (line 1485) | def testB25131481(self):
    method testB23445244 (line 1505) | def testB23445244(self):
    method testB20559654 (line 1532) | def testB20559654(self):
    method testB23943842 (line 1553) | def testB23943842(self):
    method testB20551180 (line 1591) | def testB20551180(self):
    method testB23944849 (line 1606) | def testB23944849(self):
    method testB23935890 (line 1626) | def testB23935890(self):
    method testB28414371 (line 1642) | def testB28414371(self):
    method testB20127686 (line 1667) | def testB20127686(self):
    method testB20016122 (line 1685) | def testB20016122(self):
    method testB22527411 (line 1734) | def testB22527411(self):
    method testB20849933 (line 1749) | def testB20849933(self):
    method testB20813997 (line 1769) | def testB20813997(self):
    method testB20605036 (line 1778) | def testB20605036(self):
    method testB20562732 (line 1792) | def testB20562732(self):
    method testB20128830 (line 1804) | def testB20128830(self):
    method testB20073838 (line 1824) | def testB20073838(self):
    method testB19626808 (line 1841) | def testB19626808(self):
    method testB19547210 (line 1850) | def testB19547210(self):
    method testB19377034 (line 1864) | def testB19377034(self):
    method testB19372573 (line 1874) | def testB19372573(self):
    method testB19353268 (line 1892) | def testB19353268(self):
    method testB19287512 (line 1900) | def testB19287512(self):
    method testB19194420 (line 1925) | def testB19194420(self):
    method testB19073499 (line 1934) | def testB19073499(self):
    method testB18257115 (line 1946) | def testB18257115(self):
    method testB18256666 (line 1956) | def testB18256666(self):
    method testB18256826 (line 1974) | def testB18256826(self):
    method testB18255697 (line 1993) | def testB18255697(self):
    method testB17534869 (line 2004) | def testB17534869(self):
    method testB17489866 (line 2018) | def testB17489866(self):
    method testB17133019 (line 2035) | def testB17133019(self):
    method testB17011869 (line 2060) | def testB17011869(self):
    method testB16783631 (line 2087) | def testB16783631(self):
    method testB16572361 (line 2104) | def testB16572361(self):
    method testB15884241 (line 2121) | def testB15884241(self):
    method testB15697268 (line 2145) | def testB15697268(self):
    method testB15597568 (line 2170) | def testB15597568(self):
    method testB15542157 (line 2188) | def testB15542157(self):
    method testB15438132 (line 2199) | def testB15438132(self):
    method testB14468247 (line 2234) | def testB14468247(self):
    method testB14406499 (line 2249) | def testB14406499(self):
    method testB13900309 (line 2262) | def testB13900309(self):
    method testB67935687 (line 2325) | def testB67935687(self):

FILE: yapftests/reformatter_facebook_test.py
  class TestsForFacebookStyle (line 25) | class TestsForFacebookStyle(yapf_test_helper.YAPFTest):
    method setUpClass (line 28) | def setUpClass(cls):
    method testNoNeedForLineBreaks (line 31) | def testNoNeedForLineBreaks(self):
    method testDedentClosingBracket (line 44) | def testDedentClosingBracket(self):
    method testBreakAfterOpeningBracketIfContentsTooBig (line 60) | def testBreakAfterOpeningBracketIfContentsTooBig(self):
    method testDedentClosingBracketWithComments (line 75) | def testDedentClosingBracketWithComments(self):
    method testDedentImportAsNames (line 96) | def testDedentImportAsNames(self):
    method testDedentTestListGexp (line 108) | def testDedentTestListGexp(self):
    method testBrokenIdempotency (line 146) | def testBrokenIdempotency(self):
    method testIfExprHangingIndent (line 176) | def testIfExprHangingIndent(self):
    method testSimpleDedenting (line 199) | def testSimpleDedenting(self):
    method testDedentingWithSubscripts (line 213) | def testDedentingWithSubscripts(self):
    method testDedentingCallsWithInnerLists (line 236) | def testDedentingCallsWithInnerLists(self):
    method testDedentingListComprehension (line 247) | def testDedentingListComprehension(self):
    method testMustSplitDedenting (line 325) | def testMustSplitDedenting(self):
    method testDedentIfConditional (line 337) | def testDedentIfConditional(self):
    method testDedentSet (line 351) | def testDedentSet(self):
    method testDedentingInnerScope (line 367) | def testDedentingInnerScope(self):
    method testCommentWithNewlinesInPrefix (line 385) | def testCommentWithNewlinesInPrefix(self):
    method testIfStmtClosingBracket (line 414) | def testIfStmtClosingBracket(self):

FILE: yapftests/reformatter_pep8_test.py
  class TestsForPEP8Style (line 25) | class TestsForPEP8Style(yapf_test_helper.YAPFTest):
    method setUpClass (line 28) | def setUpClass(cls):  # pylint: disable=g-missing-super-call
    method testIndent4 (line 31) | def testIndent4(self):
    method testSingleLineIfStatements (line 43) | def testSingleLineIfStatements(self):
    method testBlankBetweenClassAndDef (line 52) | def testBlankBetweenClassAndDef(self):
    method testBlankBetweenDefsInClass (line 67) | def testBlankBetweenDefsInClass(self):
    method testSingleWhiteBeforeTrailingComment (line 92) | def testSingleWhiteBeforeTrailingComment(self):
    method testSpaceBetweenEndingCommandAndClosingBracket (line 104) | def testSpaceBetweenEndingCommandAndClosingBracket(self):
    method testContinuedNonOutdentedLine (line 116) | def testContinuedNonOutdentedLine(self):
    method testWrappingPercentExpressions (line 126) | def testWrappingPercentExpressions(self):
    method testAlignClosingBracketWithVisualIndentation (line 150) | def testAlignClosingBracketWithVisualIndentation(self):
    method testIndentSizeChanging (line 187) | def testIndentSizeChanging(self):
    method testHangingIndentCollision (line 200) | def testHangingIndentCollision(self):
    method testSplittingBeforeLogicalOperator (line 239) | def testSplittingBeforeLogicalOperator(self):
    method testContiguousListEndingWithComment (line 272) | def testContiguousListEndingWithComment(self):
    method testSplittingBeforeFirstArgument (line 287) | def testSplittingBeforeFirstArgument(self):
    method testSplittingExpressionsInsideSubscripts (line 309) | def testSplittingExpressionsInsideSubscripts(self):
    method testSplitListsAndDictSetMakersIfCommaTerminated (line 322) | def testSplitListsAndDictSetMakersIfCommaTerminated(self):
    method testSplitAroundNamedAssigns (line 342) | def testSplitAroundNamedAssigns(self):
    method testUnaryOperator (line 360) | def testUnaryOperator(self):
    method testNoSplitBeforeDictValue (line 376) | def testNoSplitBeforeDictValue(self):
    method testBitwiseOperandSplitting (line 464) | def testBitwiseOperandSplitting(self):
    method testNoBlankLinesOnlyForFirstNestedObject (line 487) | def testNoBlankLinesOnlyForFirstNestedObject(self):
    method testSplitBeforeArithmeticOperators (line 521) | def testSplitBeforeArithmeticOperators(self):
    method testListSplitting (line 542) | def testListSplitting(self):
    method testNoBlankLineBeforeNestedFuncOrClass (line 556) | def testNoBlankLineBeforeNestedFuncOrClass(self):
    method testParamListIndentationCollision1 (line 597) | def testParamListIndentationCollision1(self):
    method testParamListIndentationCollision2 (line 625) | def testParamListIndentationCollision2(self):
    method testParamListIndentationCollision3 (line 634) | def testParamListIndentationCollision3(self):
    method testTwoWordComparisonOperators (line 652) | def testTwoWordComparisonOperators(self):
    method testStableInlinedDictionaryFormatting (line 666) | def testStableInlinedDictionaryFormatting(self):
  class TestsForSpacesInsideBrackets (line 690) | class TestsForSpacesInsideBrackets(yapf_test_helper.YAPFTest):
    method testEnabled (line 721) | def testEnabled(self):
    method testDefault (line 760) | def testDefault(self):
  class TestsForSpacesAroundSubscriptColon (line 799) | class TestsForSpacesAroundSubscriptColon(yapf_test_helper.YAPFTest):
    method testEnabled (line 814) | def testEnabled(self):
    method testWithSpaceInsideBrackets (line 832) | def testWithSpaceInsideBrackets(self):
    method testDefault (line 851) | def testDefault(self):

FILE: yapftests/reformatter_python3_test.py
  class TestsForPython3Code (line 26) | class TestsForPython3Code(yapf_test_helper.YAPFTest):
    method setUpClass (line 30) | def setUpClass(cls):  # pylint: disable=g-missing-super-call
    method testTypedNames (line 33) | def testTypedNames(self):
    method testTypedNameWithLongNamedArg (line 48) | def testTypedNameWithLongNamedArg(self):
    method testKeywordOnlyArgSpecifier (line 61) | def testKeywordOnlyArgSpecifier(self):
    method testAnnotations (line 73) | def testAnnotations(self):
    method testExecAsNonKeyword (line 85) | def testExecAsNonKeyword(self):
    method testAsyncFunctions (line 91) | def testAsyncFunctions(self):
    method testNoSpacesAroundPowerOperator (line 111) | def testNoSpacesAroundPowerOperator(self):
    method testSpacesAroundDefaultOrNamedAssign (line 130) | def testSpacesAroundDefaultOrNamedAssign(self):
    method testTypeHint (line 150) | def testTypeHint(self):
    method testMatrixMultiplication (line 170) | def testMatrixMultiplication(self):
    method testNoneKeyword (line 180) | def testNoneKeyword(self):
    method testAsyncWithPrecedingComment (line 187) | def testAsyncWithPrecedingComment(self):
    method testAsyncFunctionsNested (line 213) | def testAsyncFunctionsNested(self):
    method testKeepTypesIntact (line 223) | def testKeepTypesIntact(self):
    method testContinuationIndentWithAsync (line 239) | def testContinuationIndentWithAsync(self):
    method testSplittingArguments (line 255) | def testSplittingArguments(self):
    method testDictUnpacking (line 322) | def testDictUnpacking(self):
    method testMultilineFormatString (line 345) | def testMultilineFormatString(self):
    method testEllipses (line 356) | def testEllipses(self):
    method testFunctionTypedReturnNextLine (line 365) | def testFunctionTypedReturnNextLine(self):
    method testFunctionTypedReturnSameLine (line 376) | def testFunctionTypedReturnSameLine(self):
    method testAsyncForElseNotIndentedInsideBody (line 385) | def testAsyncForElseNotIndentedInsideBody(self):
    method testForElseInAsyncNotMixedWithAsyncFor (line 399) | def testForElseInAsyncNotMixedWithAsyncFor(self):
    method testParameterListIndentationConflicts (line 410) | def testParameterListIndentationConflicts(self):
    method testTypeHintedYieldExpression (line 429) | def testTypeHintedYieldExpression(self):
    method testSyntaxMatch (line 438) | def testSyntaxMatch(self):
    method testParenthsizedContextManager (line 462) | def testParenthsizedContextManager(self):
    method testUnpackedTuple (line 478) | def testUnpackedTuple(self):
    method testTypedTuple (line 496) | def testTypedTuple(self):
    method testWalrusOperator (line 506) | def testWalrusOperator(self):
    method testCondAssign (line 524) | def testCondAssign(self):
    method testCopyDictionary (line 555) | def testCopyDictionary(self):

FILE: yapftests/reformatter_style_config_test.py
  class TestsForStyleConfig (line 25) | class TestsForStyleConfig(yapf_test_helper.YAPFTest):
    method setUp (line 27) | def setUp(self):
    method testSetGlobalStyle (line 30) | def testSetGlobalStyle(self):
    method testOperatorNoSpaceStyle (line 59) | def testOperatorNoSpaceStyle(self):
    method testOperatorPrecedenceStyle (line 81) | def testOperatorPrecedenceStyle(self):
    method testNoSplitBeforeFirstArgumentStyle1 (line 124) | def testNoSplitBeforeFirstArgumentStyle1(self):
    method testNoSplitBeforeFirstArgumentStyle2 (line 165) | def testNoSplitBeforeFirstArgumentStyle2(self):

FILE: yapftests/split_penalty_test.py
  class SplitPenaltyTest (line 35) | class SplitPenaltyTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 38) | def setUpClass(cls):
    method _ParseAndComputePenalties (line 41) | def _ParseAndComputePenalties(self, code, dumptree=False):
    method _CheckPenalties (line 58) | def _CheckPenalties(self, tree, list_of_expected):
    method testUnbreakable (line 81) | def testUnbreakable(self):
    method testStronglyConnected (line 164) | def testStronglyConnected(self):
    method testFuncCalls (line 215) | def testFuncCalls(self):

FILE: yapftests/style_test.py
  class UtilsTest (line 29) | class UtilsTest(yapf_test_helper.YAPFTest):
    method testContinuationAlignStyleStringConverter (line 31) | def testContinuationAlignStyleStringConverter(self):
    method testStringListConverter (line 56) | def testStringListConverter(self):
    method testBoolConverter (line 63) | def testBoolConverter(self):
    method testIntListConverter (line 69) | def testIntListConverter(self):
    method testIntOrIntListConverter (line 74) | def testIntOrIntListConverter(self):
  function _LooksLikeGoogleStyle (line 79) | def _LooksLikeGoogleStyle(cfg):
  function _LooksLikePEP8Style (line 83) | def _LooksLikePEP8Style(cfg):
  function _LooksLikeFacebookStyle (line 87) | def _LooksLikeFacebookStyle(cfg):
  function _LooksLikeYapfStyle (line 91) | def _LooksLikeYapfStyle(cfg):
  class PredefinedStylesByNameTest (line 95) | class PredefinedStylesByNameTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 98) | def setUpClass(cls):  # pylint: disable=g-missing-super-call
    method testDefault (line 101) | def testDefault(self):
    method testPEP8ByName (line 106) | def testPEP8ByName(self):
    method testGoogleByName (line 111) | def testGoogleByName(self):
    method testYapfByName (line 116) | def testYapfByName(self):
    method testFacebookByName (line 121) | def testFacebookByName(self):
  class StyleFromFileTest (line 127) | class StyleFromFileTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 130) | def setUpClass(cls):  # pylint: disable=g-missing-super-call
    method tearDownClass (line 135) | def tearDownClass(cls):  # pylint: disable=g-missing-super-call
    method testDefaultBasedOnStyle (line 138) | def testDefaultBasedOnStyle(self):
    method testDefaultBasedOnPEP8Style (line 148) | def testDefaultBasedOnPEP8Style(self):
    method testDefaultBasedOnGoogleStyle (line 159) | def testDefaultBasedOnGoogleStyle(self):
    method testDefaultBasedOnFacebookStyle (line 170) | def testDefaultBasedOnFacebookStyle(self):
    method testBoolOptionValue (line 181) | def testBoolOptionValue(self):
    method testStringListOptionValue (line 194) | def testStringListOptionValue(self):
    method testErrorNoStyleFile (line 205) | def testErrorNoStyleFile(self):
    method testErrorNoStyleSection (line 210) | def testErrorNoStyleSection(self):
    method testErrorUnknownStyleOption (line 220) | def testErrorUnknownStyleOption(self):
    method testPyprojectTomlNoYapfSection (line 231) | def testPyprojectTomlNoYapfSection(self):
    method testPyprojectTomlParseYapfSection (line 238) | def testPyprojectTomlParseYapfSection(self):
  class StyleFromDict (line 253) | class StyleFromDict(yapf_test_helper.YAPFTest):
    method setUpClass (line 256) | def setUpClass(cls):  # pylint: disable=g-missing-super-call
    method testDefaultBasedOnStyle (line 259) | def testDefaultBasedOnStyle(self):
    method testDefaultBasedOnStyleBadDict (line 269) | def testDefaultBasedOnStyleBadDict(self):
  class StyleFromCommandLine (line 278) | class StyleFromCommandLine(yapf_test_helper.YAPFTest):
    method setUpClass (line 281) | def setUpClass(cls):  # pylint: disable=g-missing-super-call
    method testDefaultBasedOnStyle (line 284) | def testDefaultBasedOnStyle(self):
    method testDefaultBasedOnStyleNotStrict (line 292) | def testDefaultBasedOnStyleNotStrict(self):
    method testDefaultBasedOnExplicitlyUnicodeTypeString (line 300) | def testDefaultBasedOnExplicitlyUnicodeTypeString(self):
    method testDefaultBasedOnDetaultTypeString (line 304) | def testDefaultBasedOnDetaultTypeString(self):
    method testDefaultBasedOnStyleBadString (line 308) | def testDefaultBasedOnStyleBadString(self):
  class StyleHelp (line 317) | class StyleHelp(yapf_test_helper.YAPFTest):
    method testHelpKeys (line 319) | def testHelpKeys(self):

FILE: yapftests/subtype_assigner_test.py
  class SubtypeAssignerTest (line 26) | class SubtypeAssignerTest(yapf_test_helper.YAPFTest):
    method _CheckFormatTokenSubtypes (line 28) | def _CheckFormatTokenSubtypes(self, llines, list_of_expected):
    method testFuncDefDefaultAssign (line 46) | def testFuncDefDefaultAssign(self):
    method testFuncCallWithDefaultAssign (line 108) | def testFuncCallWithDefaultAssign(self):
    method testSetComprehension (line 132) | def testSetComprehension(self):
    method testDictComprehension (line 284) | def testDictComprehension(self):
    method testUnaryNotOperator (line 409) | def testUnaryNotOperator(self):
    method testBitwiseOperators (line 417) | def testBitwiseOperators(self):
    method testArithmeticOperators (line 446) | def testArithmeticOperators(self):
    method testSubscriptColon (line 487) | def testSubscriptColon(self):
    method testFunctionCallWithStarExpression (line 505) | def testFunctionCallWithStarExpression(self):

FILE: yapftests/utils.py
  function stdout_redirector (line 25) | def stdout_redirector(stream):  # pylint: disable=invalid-name
  function NamedTempFile (line 45) | def NamedTempFile(mode='w+b',
  function TempFileContents (line 70) | def TempFileContents(dirname,

FILE: yapftests/yapf_test.py
  class FormatCodeTest (line 40) | class FormatCodeTest(yapf_test_helper.YAPFTest):
    method _Check (line 42) | def _Check(self, unformatted_code, expected_formatted_code):
    method testSimple (line 47) | def testSimple(self):
    method testNoEndingNewline (line 53) | def testNoEndingNewline(self):
  class FormatFileTest (line 64) | class FormatFileTest(yapf_test_helper.YAPFTest):
    method setUp (line 66) | def setUp(self):  # pylint: disable=g-missing-super-call
    method tearDown (line 69) | def tearDown(self):  # pylint: disable=g-missing-super-call
    method testFormatFile (line 72) | def testFormatFile(self):
    method testDisableLinesPattern (line 92) | def testDisableLinesPattern(self):
    method testDisableAndReenableLinesPattern (line 113) | def testDisableAndReenableLinesPattern(self):
    method testFmtOnOff (line 136) | def testFmtOnOff(self):
    method testDisablePartOfMultilineComment (line 159) | def testDisablePartOfMultilineComment(self):
    method testEnabledDisabledSameComment (line 202) | def testEnabledDisabledSameComment(self):
    method testFormatFileLinesSelection (line 215) | def testFormatFileLinesSelection(self):
    method testFormatFileDiff (line 245) | def testFormatFileDiff(self):
    method testFormatFileInPlace (line 254) | def testFormatFileInPlace(self):
    method testNoFile (line 270) | def testNoFile(self):
    method testCommentsUnformatted (line 278) | def testCommentsUnformatted(self):
    method testDisabledHorizontalFormattingOnNewLine (line 290) | def testDisabledHorizontalFormattingOnNewLine(self):
    method testSplittingSemicolonStatements (line 301) | def testSplittingSemicolonStatements(self):
    method testSemicolonStatementsDisabled (line 320) | def testSemicolonStatementsDisabled(self):
    method testDisabledSemiColonSeparatedStatements (line 338) | def testDisabledSemiColonSeparatedStatements(self):
    method testDisabledMultilineStringInDictionary (line 347) | def testDisabledMultilineStringInDictionary(self):
    method testDisabledWithPrecedingText (line 366) | def testDisabledWithPrecedingText(self):
    method testCRLFLineEnding (line 385) | def testCRLFLineEnding(self):
  class CommandLineTest (line 392) | class CommandLineTest(yapf_test_helper.YAPFTest):
    method setUpClass (line 396) | def setUpClass(cls):  # pylint: disable=g-missing-super-call
    method tearDownClass (line 400) | def tearDownClass(cls):  # pylint: disable=g-missing-super-call
    method assertYapfReformats (line 403) | def assertYapfReformats(self,
    method testInPlaceReformatting (line 431) | def testInPlaceReformatting(self):
    method testInPlaceReformattingBlank (line 448) | def testInPlaceReformattingBlank(self):
    method testInPlaceReformattingWindowsNewLine (line 459) | def testInPlaceReformattingWindowsNewLine(self):
    method testInPlaceReformattingNoNewLine (line 470) | def testInPlaceReformattingNoNewLine(self):
    method testInPlaceReformattingEmpty (line 484) | def testInPlaceReformattingEmpty(self):
    method testPrintModified (line 495) | def testPrintModified(self):
    method testReadFromStdin (line 505) | def testReadFromStdin(self):
    method testReadFromStdinWithEscapedStrings (line 516) | def testReadFromStdinWithEscapedStrings(self):
    method testSetYapfStyle (line 525) | def testSetYapfStyle(self):
    method testSetCustomStyleBasedOnYapf (line 539) | def testSetCustomStyleBasedOnYapf(self):
    method testSetCustomStyleSpacesBeforeComment (line 559) | def testSetCustomStyleSpacesBeforeComment(self):
    method testReadSingleLineCodeFromStdin (line 578) | def testReadSingleLineCodeFromStdin(self):
    method testEncodingVerification (line 587) | def testEncodingVerification(self):
    method testReformattingSpecificLines (line 605) | def testReformattingSpecificLines(self):
    method testOmitFormattingLinesBeforeDisabledFunctionComment (line 635) | def testOmitFormattingLinesBeforeDisabledFunctionComment(self):
    method testReformattingSkippingLines (line 655) | def testReformattingSkippingLines(self):
    method testReformattingSkippingToEndOfFile (line 682) | def testReformattingSkippingToEndOfFile(self):
    method testReformattingSkippingSingleLine (line 721) | def testReformattingSkippingSingleLine(self):
    method testDisableWholeDataStructure (line 744) | def testDisableWholeDataStructure(self):
    method testDisableButAdjustIndentations (line 759) | def testDisableButAdjustIndentations(self):
    method testRetainingHorizontalWhitespace (line 776) | def testRetainingHorizontalWhitespace(self):
    method testRetainingVerticalWhitespace (line 799) | def testRetainingVerticalWhitespace(self):
    method testVerticalSpacingWithCommentWithContinuationMarkers (line 879) | def testVerticalSpacingWithCommentWithContinuationMarkers(self):
    method testRetainingSemicolonsWhenSpecifyingLines (line 901) | def testRetainingSemicolonsWhenSpecifyingLines(self):
    method testDisabledMultilineStrings (line 919) | def testDisabledMultilineStrings(self):
    method testDisableWhenSpecifyingLines (line 945) | def testDisableWhenSpecifyingLines(self):
    method testDisableFormattingInDataLiteral (line 975) | def testDisableFormattingInDataLiteral(self):
    method testRetainVerticalFormattingBetweenDisabledAndEnabledLines (line 1015) | def testRetainVerticalFormattingBetweenDisabledAndEnabledLines(self):
    method testRetainVerticalFormattingBetweenDisabledLines (line 1041) | def testRetainVerticalFormattingBetweenDisabledLines(self):
    method testFormatLinesSpecifiedInMiddleOfExpression (line 1065) | def testFormatLinesSpecifiedInMiddleOfExpression(self):
    method testCommentFollowingMultilineString (line 1091) | def testCommentFollowingMultilineString(self):
    method testDedentClosingBracket (line 1113) | def testDedentClosingBracket(self):
    method testCoalesceBrackets (line 1167) | def testCoalesceBrackets(self):
    method testPseudoParenSpaces (line 1195) | def testPseudoParenSpaces(self):
    method testMultilineCommentFormattingDisabled (line 1211) | def testMultilineCommentFormattingDisabled(self):
    method testTrailingCommentsWithDisabledFormatting (line 1245) | def testTrailingCommentsWithDisabledFormatting(self):
    method testUseTabs (line 1265) | def testUseTabs(self):
    method testUseTabsWith (line 1288) | def testUseTabsWith(self):
    method testUseTabsContinuationAlignStyleFixed (line 1312) | def testUseTabsContinuationAlignStyleFixed(self):
    method testUseTabsContinuationAlignStyleVAlignRight (line 1340) | def testUseTabsContinuationAlignStyleVAlignRight(self):
    method testUseSpacesContinuationAlignStyleFixed (line 1368) | def testUseSpacesContinuationAlignStyleFixed(self):
    method testUseSpacesContinuationAlignStyleVAlignRight (line 1395) | def testUseSpacesContinuationAlignStyleVAlignRight(self):
    method testStyleOutputRoundTrip (line 1422) | def testStyleOutputRoundTrip(self):
    method testSpacingBeforeComments (line 1446) | def testSpacingBeforeComments(self):
    method testSpacingBeforeCommentsInDicts (line 1472) | def testSpacingBeforeCommentsInDicts(self):
    method testDisableWithLinesOption (line 1508) | def testDisableWithLinesOption(self):
    method testDisableWithLineRanges (line 1532) | def testDisableWithLineRanges(self):
  class BadInputTest (line 1557) | class BadInputTest(yapf_test_helper.YAPFTest):
    method testBadSyntax (line 1560) | def testBadSyntax(self):
    method testBadCode (line 1564) | def testBadCode(self):
  class DiffIndentTest (line 1569) | class DiffIndentTest(yapf_test_helper.YAPFTest):
    method _OwnStyle (line 1572) | def _OwnStyle():
    method _Check (line 1578) | def _Check(self, unformatted_code, expected_formatted_code):
    method testSimple (line 1583) | def testSimple(self):
  class HorizontallyAlignedTrailingCommentsTest (line 1595) | class HorizontallyAlignedTrailingCommentsTest(yapf_test_helper.YAPFTest):
    method _OwnStyle (line 1598) | def _OwnStyle():
    method _Check (line 1607) | def _Check(self, unformatted_code, expected_formatted_code):
    method testSimple (line 1612) | def testSimple(self):
    method testBlock (line 1633) | def testBlock(self):
    method testBlockWithLongLine (line 1652) | def testBlockWithLongLine(self):
    method testBlockFuncSuffix (line 1671) | def testBlockFuncSuffix(self):
    method testBlockCommentSuffix (line 1697) | def testBlockCommentSuffix(self):
    method testBlockIndentedFuncSuffix (line 1720) | def testBlockIndentedFuncSuffix(self):
    method testBlockIndentedCommentSuffix (line 1753) | def testBlockIndentedCommentSuffix(self):
    method testBlockMultiIndented (line 1778) | def testBlockMultiIndented(self):
    method testArgs (line 1807) | def testArgs(self):
    method testDisableBlock (line 1832) | def testDisableBlock(self):
    method testDisabledLine (line 1859) | def testDisabledLine(self):
  class _SpacesAroundDictListTupleTestImpl (line 1875) | class _SpacesAroundDictListTupleTestImpl(yapf_test_helper.YAPFTest):
    method _OwnStyle (line 1878) | def _OwnStyle():
    method _Check (line 1885) | def _Check(self, unformatted_code, expected_formatted_code):
    method setUp (line 1890) | def setUp(self):
  class SpacesAroundDictTest (line 1894) | class SpacesAroundDictTest(_SpacesAroundDictListTupleTestImpl):
    method _OwnStyle (line 1897) | def _OwnStyle(cls):
    method testStandard (line 1903) | def testStandard(self):
  class SpacesAroundListTest (line 1941) | class SpacesAroundListTest(_SpacesAroundDictListTupleTestImpl):
    method _OwnStyle (line 1944) | def _OwnStyle(cls):
    method testStandard (line 1950) | def testStandard(self):
  class SpacesAroundTupleTest (line 1996) | class SpacesAroundTupleTest(_SpacesAroundDictListTupleTestImpl):
    method _OwnStyle (line 1999) | def _OwnStyle(cls):
    method testStandard (line 2005) | def testStandard(self):

FILE: yapftests/yapf_test_helper.py
  class YAPFTest (line 32) | class YAPFTest(unittest.TestCase):
    method __init__ (line 34) | def __init__(self, *args):
    method assertCodeEqual (line 37) | def assertCodeEqual(self, expected_code, code):
  function ParseAndUnwrap (line 63) | def ParseAndUnwrap(code, dumptree=False):