From 07f45a0bd358eca9be9dec0d2a5803ce2c4ac968 Mon Sep 17 00:00:00 2001 From: Erez Shinan Date: Sat, 10 Feb 2018 12:37:34 +0200 Subject: [PATCH] Style fixes --- lark/common.py | 4 +-- lark/parser_frontends.py | 60 ++++++++++++++++++++-------------------- lark/parsers/cyk.py | 2 +- lark/parsers/earley.py | 11 ++------ lark/parsers/xearley.py | 6 ++-- lark/tools/nearley.py | 4 +-- 6 files changed, 41 insertions(+), 46 deletions(-) diff --git a/lark/common.py b/lark/common.py index c0c6cf3..ad16cfe 100644 --- a/lark/common.py +++ b/lark/common.py @@ -41,11 +41,11 @@ class UnexpectedToken(ParseError): class LexerConf: - def __init__(self, tokens, ignore=(), postlex=None, callbacks={}): + def __init__(self, tokens, ignore=(), postlex=None, callbacks=None): self.tokens = tokens self.ignore = ignore self.postlex = postlex - self.callbacks = callbacks + self.callbacks = callbacks or {} class ParserConf: def __init__(self, rules, callback, start): diff --git a/lark/parser_frontends.py b/lark/parser_frontends.py index 561bd8b..0ea3138 100644 --- a/lark/parser_frontends.py +++ b/lark/parser_frontends.py @@ -139,36 +139,36 @@ class XEarley: class CYK(WithLexer): - def __init__(self, lexer_conf, parser_conf, options=None): - self.init_traditional_lexer(lexer_conf) - - self._analysis = GrammarAnalyzer(parser_conf) - self._parser = cyk.Parser(parser_conf.rules, parser_conf.start) - - self._postprocess = {} - for rule in parser_conf.rules: - a = rule.alias - self._postprocess[a] = a if callable(a) else (a and getattr(parser_conf.callback, a)) - - def parse(self, text): - tokens = list(self.lex(text)) - parse = self._parser.parse(tokens) - parse = self._transform(parse) - return parse - - def _transform(self, tree): - subtrees = list(tree.iter_subtrees()) - for subtree in subtrees: - subtree.children = [self._apply_callback(c) if isinstance(c, Tree) else c for c in subtree.children] - - return self._apply_callback(tree) - - def _apply_callback(self, tree): - children = tree.children - callback = self._postprocess[tree.rule.alias] - assert callback, tree.rule.alias - r = callback(children) - return r + def __init__(self, lexer_conf, parser_conf, options=None): + self.init_traditional_lexer(lexer_conf) + + self._analysis = GrammarAnalyzer(parser_conf) + self._parser = cyk.Parser(parser_conf.rules, parser_conf.start) + + self._postprocess = {} + for rule in parser_conf.rules: + a = rule.alias + self._postprocess[a] = a if callable(a) else (a and getattr(parser_conf.callback, a)) + + def parse(self, text): + tokens = list(self.lex(text)) + parse = self._parser.parse(tokens) + parse = self._transform(parse) + return parse + + def _transform(self, tree): + subtrees = list(tree.iter_subtrees()) + for subtree in subtrees: + subtree.children = [self._apply_callback(c) if isinstance(c, Tree) else c for c in subtree.children] + + return self._apply_callback(tree) + + def _apply_callback(self, tree): + children = tree.children + callback = self._postprocess[tree.rule.alias] + assert callback, tree.rule.alias + r = callback(children) + return r def get_frontend(parser, lexer): diff --git a/lark/parsers/cyk.py b/lark/parsers/cyk.py index 1f9a0fc..9d643aa 100644 --- a/lark/parsers/cyk.py +++ b/lark/parsers/cyk.py @@ -139,7 +139,7 @@ class Parser(object): """Converts a RuleNode parse tree to a lark Tree.""" orig_rule = self.orig_rules[rule_node.rule.alias] children = [] - for i, child in enumerate(rule_node.children): + for child in rule_node.children: if isinstance(child, RuleNode): children.append(self._to_tree(child)) else: diff --git a/lark/parsers/earley.py b/lark/parsers/earley.py index 862ad6b..39c39a9 100644 --- a/lark/parsers/earley.py +++ b/lark/parsers/earley.py @@ -4,7 +4,7 @@ # When the parse ends successfully, a disambiguation stage resolves all ambiguity # (right now ambiguity resolution is not developed beyond the needs of lark) # Afterwards the parse tree is reduced (transformed) according to user callbacks. -# I use the no-recursion version of Transformer and Visitor, because the tree might be +# I use the no-recursion version of Transformer, because the tree might be # deeper than Python's recursion limit (a bit absurd, but that's life) # # The algorithm keeps track of each state set, using a corresponding Column instance. @@ -14,7 +14,7 @@ # Email : erezshin@gmail.com from ..common import ParseError, UnexpectedToken, is_terminal -from ..tree import Tree, Visitor_NoRecurse, Transformer_NoRecurse +from ..tree import Tree, Transformer_NoRecurse from .grammar_analysis import GrammarAnalyzer @@ -234,9 +234,4 @@ class ApplyCallbacks(Transformer_NoRecurse): self.postprocess = postprocess def drv(self, tree): - children = tree.children - callback = self.postprocess[tree.rule] - if callback: - return callback(children) - else: - return Tree(rule.origin, children) + return self.postprocess[tree.rule](tree.children) diff --git a/lark/parsers/xearley.py b/lark/parsers/xearley.py index d9234ab..45c9fee 100644 --- a/lark/parsers/xearley.py +++ b/lark/parsers/xearley.py @@ -20,7 +20,7 @@ from collections import defaultdict -from ..common import ParseError, UnexpectedToken, is_terminal +from ..common import ParseError, is_terminal from ..lexer import Token, UnexpectedInput from ..tree import Tree from .grammar_analysis import GrammarAnalyzer @@ -78,7 +78,7 @@ class Parser: raise ParseError('Infinite recursion detected! (rule %s)' % item.rule) column.add(new_items) - def scan(i, token, column): + def scan(i, column): to_scan = column.to_scan for x in self.ignore: @@ -123,7 +123,7 @@ class Parser: column = column0 for i, token in enumerate(stream): predict_and_complete(column) - column = scan(i, token, column) + column = scan(i, column) if token == '\n': text_line += 1 diff --git a/lark/tools/nearley.py b/lark/tools/nearley.py index 5e277a1..eead26d 100644 --- a/lark/tools/nearley.py +++ b/lark/tools/nearley.py @@ -5,7 +5,7 @@ import sys import codecs -from lark import Lark, InlineTransformer, Transformer +from lark import Lark, InlineTransformer nearley_grammar = r""" start: (ruledef|directive)+ @@ -172,7 +172,7 @@ def create_code_for_nearley_grammar(g, start, builtin_path, folder_path): def main(fn, start, nearley_lib): with codecs.open(fn, encoding='utf8') as f: grammar = f.read() - return (create_code_for_nearley_grammar(grammar, start, os.path.join(nearley_lib, 'builtin'), os.path.abspath(os.path.dirname(fn)))) + return create_code_for_nearley_grammar(grammar, start, os.path.join(nearley_lib, 'builtin'), os.path.abspath(os.path.dirname(fn))) if __name__ == '__main__':