def compile_q_objects(search):
compiler = wrapGrammar(DjangoCompiler)
try:
qs = compiler(search).expr()
return qs, None
except (BadDirective, ParseError) as why:
return None, why.formatReason()
def compile_q_objects(search):
compiler = wrapGrammar(DjangoCompiler)
try:
qs = compiler(search).expr()
return qs, None
except (BadDirective, ParseError) as why:
return None, str(why)
def compile_q_objects(search):
search = search.strip()
compiler = wrapGrammar(DjangoCompiler)
try:
qs = compiler(search).expr()
return qs, None
except (BadDirective, ParseError) as why:
return None, str(why)
except (BadType, ParseError) as why:
return None, str(why)
def _make_edn_grammar(tagged_value_handler):
# XXX: At last, my pact with the dark lord is fulfilled.
#
# I can't find any obvious way to specify bindings at the same time as
# specifying input. Making a new grammar for every set of handlers is
# expensive. This hideous alternative seems to work.
class _specialized_edn(_unwrapped_edn):
pass
globals = dict(_specialized_edn.globals)
globals.update({"TaggedValue": tagged_value_handler})
_specialized_edn.globals = globals
return wrapGrammar(_specialized_edn)
def _make_edn_grammar(tagged_value_handler):
# XXX: At last, my pact with the dark lord is fulfilled.
#
# I can't find any obvious way to specify bindings at the same time as
# specifying input. Making a new grammar for every set of handlers is
# expensive. This hideous alternative seems to work.
class _specialized_edn(_unwrapped_edn):
pass
globals = dict(_specialized_edn.globals)
globals.update({'TaggedValue': tagged_value_handler})
_specialized_edn.globals = globals
return wrapGrammar(_specialized_edn)
def load_grammar(compile=True):
if compile:
# re/compile if necessary:
if not os.path.exists(COMPILED_GRAMMAR_FILE) or \
os.path.getmtime(GRAMMAR_FILE) > os.path.getmtime(COMPILED_GRAMMAR_FILE):
compile_grammar()
# load it like this - there doesn't seem to be a better user API available:
import kgtk.kypher.grammar_compiled as cgc
cgram = cgc.createParserClass(ometa.grammar.OMetaBase, {})
return parsley.wrapGrammar(cgram)
else:
# rebuild the grammar from scratch:
return parsley.makeGrammar(KYPHER_GRAMMAR, {})
def _make_edn_grammar(tagged_value_handler):
# XXX: At last, my pact with the dark lord is fulfilled.
#
# I can't find any obvious way to specify bindings at the same time as
# specifying input. Making a new grammar for every set of handlers is
# expensive. This hideous alternative seems to work.
class _specialized_edn(_unwrapped_edn):
pass
globals = dict(_specialized_edn.globals)
globals.update({"TaggedValue": tagged_value_handler})
_specialized_edn.globals = globals
return wrapGrammar(_specialized_edn)
edn = wrapGrammar(_unwrapped_edn)
def loads(string, handlers=None):
if handlers is None:
handlers = BUILTIN_READ_HANDLERS
grammar = _make_edn_grammar(partial(make_tagged_value, handlers))
return grammar(string).edn()
def _dump_bool(obj):
if obj:
return "true"
else:
return "false"
def make_debug_compiler():
return wrapGrammar(DebugCompiler)
def __init__(self, *args, **kwargs):
self.bindings = self.setupBindings()
self.grammar = wrapGrammar(
loadGrammar(parseproto.dns, "grammar", self.bindings))
def make_debug_compiler():
return wrapGrammar(DebugCompiler)
def _make_edn_grammar(tagged_value_handler):
# XXX: At last, my pact with the dark lord is fulfilled.
#
# I can't find any obvious way to specify bindings at the same time as
# specifying input. Making a new grammar for every set of handlers is
# expensive. This hideous alternative seems to work.
class _specialized_edn(_unwrapped_edn):
pass
globals = dict(_specialized_edn.globals)
globals.update({'TaggedValue': tagged_value_handler})
_specialized_edn.globals = globals
return wrapGrammar(_specialized_edn)
edn = wrapGrammar(_unwrapped_edn)
def loads(string, handlers=None):
if handlers is None:
handlers = BUILTIN_READ_HANDLERS
grammar = _make_edn_grammar(partial(make_tagged_value, handlers))
return grammar(string).edn()
def _dump_bool(obj):
if obj:
return 'true'
else:
return 'false'
output.append(chunk.data)
elif chunk.tag.name == "QuasiExprHole":
v = vals[chunk.args[0].data]
output.append(v)
else:
raise TypeError("didn't expect %r in string template" % chunk)
pt = PrecedenceTemplate(self.nextPrecedence, output)
self.nextPrecedence = None
return pt, None
PythonExpressionUnparser = TreeTransformerGrammar.makeGrammar(
open("expression_unparser.parsley").read(),
'PythonExpressionUnparser').createParserClass(PrecedenceTransformer, globals())
PythonStatementUnparser = TreeTransformerGrammar.makeGrammar(
open("statement_unparser.parsley").read(),
'PythonStatementUnparser').createParserClass(TreeTransformerBase, globals())
if __name__ == "__main__":
from terml.parser import parseTerm as term
f = open(sys.argv[1]).read()
g = wrapGrammar(PythonParser)
stmts = g(f).file_input()
from pprint import pprint
pprint(stmts)
pt = PythonStatementUnparser.transform(stmts)[0]
print pt
def _rebuild_parser(self):
self.parser = parsley.wrapGrammar(self.grammar)
def __init__(self, *args, **kwargs):
self.bindings = self.setupBindings()
self.grammar = wrapGrammar(loadGrammar(parseproto.dns, "grammar",
self.bindings))
for host in second_hosts:
stdout.write(str(host))
if first_groups:
print '### Groups found only in the first config ###'
for group in first_groups:
stdout.write(str(group))
if second_groups:
print '### Groups found only in the second config ###'
for group in second_groups:
stdout.write(str(group))
if first_classes:
print '### Classes found only in the first config ###'
for klass in first_classes:
stdout.write(str(klass))
if second_classes:
print '### Classes found only in the second config ###'
for klass in second_classes:
stdout.write(str(klass))
iscgrammar = wrapGrammar(DhcpConfigContext)
def compare(file1, file2):
parse1 = iscgrammar(strip_comments(open(file1))).GlobalParse()
parse2 = iscgrammar(strip_comments(open(file2))).GlobalParse()
parse1.diff(parse2)
Desugarer = TreeTransformerGrammar.makeGrammar(
open("desugar_augmented_assignment.parsley").read(),
"Desugarer").createParserClass(TreeTransformerBase, {"t": t})
PythonExpressionUnparser = TreeTransformerGrammar.makeGrammar(
open("expression_unparser.parsley").read(),
'PythonExpressionUnparser').createParserClass(PrecedenceTransformer, globals())
PythonStatementUnparser = TreeTransformerGrammar.makeGrammar(
open("statement_unparser.parsley").read(),
'PythonStatementUnparser').createParserClass(TreeTransformerBase, globals())
if __name__ == "__main__":
from terml.parser import parseTerm as term
f = open(sys.argv[1]).read()
g = wrapGrammar(PythonParser)
# stmts = g(sys.argv[1] + '\n').file_input()
stmts = g(f).file_input()
from pprint import pprint
pprint(stmts)
# import pdb; pdb.set_trace()
ds = Desugarer.transform(stmts)[0]
print ds
pt = PythonStatementUnparser.transform(ds)[0]
print pt
