def create_forests(self, treelist=None):
""" This will read sentences to parse. One sentence per line, no periods etc.
:param treelist: lines of file like above.
"""
if not treelist:
treelist = []
# Clear this screen before we start creating a mess
ctrl.disable_undo() # disable tracking of changes (e.g. undo)
if self.forest:
self.forest.retire_from_drawing()
self.forests = []
start = 0
end = 10
for line in treelist:
sentence = line.strip()
if (not sentence) or sentence.startswith('#'):
continue
forest = Forest(gloss_text=sentence)
self.forests.append(forest)
parser = Parser(grammar.g, -0.0001, forest=forest)
my_success, my_dnodes = parser.parse(sentence=sentence, start='C')
print(my_success)
self.current_index = 0
self.forest = self.forests[0]
# allow change tracking (undo) again
ctrl.resume_undo()
def create_derivation(self, forest):
""" This is always called to initially turn syntax available here and some input into a
structure. Resulting structures are used to populate a forest.
:return:
"""
print('create_derivation: ', self.lexicon)
self.parser = Parser(self.lexicon, -0.0001, forest=forest)
# parser doesn't return anything, it pushes derivation steps to forest
self.parser.parse(sentence=self.sentence, start='C')
ds = forest.derivation_steps
ds.derivation_step_index = len(ds.derivation_steps) - 1
ds.jump_to_derivation_step(ds.derivation_step_index)
def derive_from_editable_lexicon(self, sentence, lexdata, semantics=''):
""" Take edited version of get_editable_lexicon output and try derivation with it.
"""
grammar = load_grammar(g=lexdata)
self.lexicon = grammar
ctrl.disable_undo()
f = ctrl.forest
f.clear()
self.sentence = sentence
self.parser = Parser(grammar, -0.0001, forest=f)
# parser doesn't return anything, it pushes derivation steps to forest
self.parser.parse(sentence=self.sentence, start='C')
ds = f.derivation_steps
ds.derivation_step_index = len(ds.derivation_steps) - 1
ds.jump_to_derivation_step(ds.derivation_step_index)
f.prepare_for_drawing()
ctrl.resume_undo()
def create_derivation(self, forest):
""" This is always called to initially turn syntax available here and some input into a
structure. Resulting structures are used to populate a forest.
:return:
"""
print('create_derivation: ', self.lexicon)
self.parser = Parser(self.lexicon, -0.0001, forest=forest)
# parser doesn't return anything, it pushes derivation steps to forest
self.parser.parse(sentence=self.sentence, start='C')
ds = forest.derivation_steps
ds.derivation_step_index = len(ds.derivation_steps) - 1
ds.jump_to_derivation_step(ds.derivation_step_index)
def derive_from_editable_lexicon(self, sentence, lexdata, semantics=''):
""" Take edited version of get_editable_lexicon output and try derivation with it.
"""
grammar = load_grammar(g=lexdata)
self.lexicon = grammar
ctrl.disable_undo()
f = ctrl.forest
f.clear()
self.sentence = sentence
self.parser = Parser(grammar, -0.0001, forest=f)
# parser doesn't return anything, it pushes derivation steps to forest
self.parser.parse(sentence=self.sentence, start='C')
ds = f.derivation_steps
ds.derivation_step_index = len(ds.derivation_steps) - 1
ds.jump_to_derivation_step(ds.derivation_step_index)
f.prepare_for_drawing()
ctrl.resume_undo()
class KSyntaxConnection(SyntaxConnection):
role = "SyntaxConnection"
supports_editable_lexicon = True
supports_secondary_labels = True
display_modes = ['Derivation tree', 'State tree', 'Bare tree', 'XBar tree']
def __init__(self):
SavedObject.__init__(self)
self.Constituent = classes.get('Constituent')
self.Feature = classes.get('Feature')
self.trees = []
self.constituents = {}
self.features = {}
self.lexicon = {}
self.rules = {}
self.sentence = ''
self.parser = None
self.syntax_display_mode = 2
for key, value in self.options.items():
self.rules[key] = value.get('default')
def get_editable_lexicon(self):
""" If it is possible to provide editable lexicon, where to get it
:return:
"""
return '\n'.join([str(const) for const in self.lexicon])
def derive_from_editable_lexicon(self, sentence, lexdata, semantics=''):
""" Take edited version of get_editable_lexicon output and try derivation with it.
"""
grammar = load_grammar(g=lexdata)
self.lexicon = grammar
ctrl.disable_undo()
f = ctrl.forest
f.clear()
self.sentence = sentence
self.parser = Parser(grammar, -0.0001, forest=f)
# parser doesn't return anything, it pushes derivation steps to forest
self.parser.parse(sentence=self.sentence, start='C')
ds = f.derivation_steps
ds.derivation_step_index = len(ds.derivation_steps) - 1
ds.jump_to_derivation_step(ds.derivation_step_index)
f.prepare_for_drawing()
ctrl.resume_undo()
def get_editable_sentence(self):
""" If the current systems supports parsing, return the current parsed string. User can
edit it and retry parsing.
:return:
"""
return self.sentence
def create_derivation(self, forest):
""" This is always called to initially turn syntax available here and some input into a
structure. Resulting structures are used to populate a forest.
:return:
"""
print('create_derivation: ', self.lexicon)
self.parser = Parser(self.lexicon, -0.0001, forest=forest)
# parser doesn't return anything, it pushes derivation steps to forest
self.parser.parse(sentence=self.sentence, start='C')
ds = forest.derivation_steps
ds.derivation_step_index = len(ds.derivation_steps) - 1
ds.jump_to_derivation_step(ds.derivation_step_index)
def set_display_mode(self, i):
self.syntax_display_mode = i
def next_display_mode(self):
self.syntax_display_mode += 1
if self.syntax_display_mode == len(self.display_modes):
self.syntax_display_mode = 0
return self.display_modes[self.syntax_display_mode]
def transform_trees_for_display(self, synobjs):
if self.syntax_display_mode == DERIVATION_TREE:
# Just derivation trees
return synobjs
elif self.syntax_display_mode == STATE_TREE:
# StateTree(dt)
res = []
for synobj in synobjs:
const = StateTree(synobj).to_constituent()
res.append(const)
return res
elif self.syntax_display_mode == BARE_TREE:
# BareTree(dt)
res = []
for synobj in synobjs:
const = BareTree(synobj).to_constituent()
res.append(const)
return res
elif self.syntax_display_mode == XBAR_TREE:
# XBarTree(dt)
res = []
for synobj in synobjs:
const = TracelessXBarTree(synobj).to_constituent()
res.append(const)
return res
else:
return synobjs
class KSyntaxConnection(SyntaxConnection):
role = "SyntaxConnection"
supports_editable_lexicon = True
supports_secondary_labels = True
display_modes = ['Derivation tree', 'State tree', 'Bare tree', 'XBar tree']
def __init__(self):
SavedObject.__init__(self)
self.Constituent = classes.get('Constituent')
self.Feature = classes.get('Feature')
self.trees = []
self.constituents = {}
self.features = {}
self.lexicon = {}
self.rules = {}
self.sentence = ''
self.parser = None
self.syntax_display_mode = 2
for key, value in self.options.items():
self.rules[key] = value.get('default')
def get_editable_lexicon(self):
""" If it is possible to provide editable lexicon, where to get it
:return:
"""
return '\n'.join([str(const) for const in self.lexicon])
def derive_from_editable_lexicon(self, sentence, lexdata, semantics=''):
""" Take edited version of get_editable_lexicon output and try derivation with it.
"""
grammar = load_grammar(g=lexdata)
self.lexicon = grammar
ctrl.disable_undo()
f = ctrl.forest
f.clear()
self.sentence = sentence
self.parser = Parser(grammar, -0.0001, forest=f)
# parser doesn't return anything, it pushes derivation steps to forest
self.parser.parse(sentence=self.sentence, start='C')
ds = f.derivation_steps
ds.derivation_step_index = len(ds.derivation_steps) - 1
ds.jump_to_derivation_step(ds.derivation_step_index)
f.prepare_for_drawing()
ctrl.resume_undo()
def get_editable_sentence(self):
""" If the current systems supports parsing, return the current parsed string. User can
edit it and retry parsing.
:return:
"""
return self.sentence
def create_derivation(self, forest):
""" This is always called to initially turn syntax available here and some input into a
structure. Resulting structures are used to populate a forest.
:return:
"""
print('create_derivation: ', self.lexicon)
self.parser = Parser(self.lexicon, -0.0001, forest=forest)
# parser doesn't return anything, it pushes derivation steps to forest
self.parser.parse(sentence=self.sentence, start='C')
ds = forest.derivation_steps
ds.derivation_step_index = len(ds.derivation_steps) - 1
ds.jump_to_derivation_step(ds.derivation_step_index)
def set_display_mode(self, i):
self.syntax_display_mode = i
def next_display_mode(self):
self.syntax_display_mode += 1
if self.syntax_display_mode == len(self.display_modes):
self.syntax_display_mode = 0
def transform_trees_for_display(self, synobjs):
if self.syntax_display_mode == 0:
# Just derivation trees
return synobjs
elif self.syntax_display_mode == 1:
# StateTree(dt)
res = []
for synobj in synobjs:
const = StateTree(synobj).to_constituent()
res.append(const)
return res
elif self.syntax_display_mode == 2:
# BareTree(dt)
res = []
for synobj in synobjs:
const = BareTree(synobj).to_constituent()
res.append(const)
return res
elif self.syntax_display_mode == 3:
# XBarTree(dt)
res = []
for synobj in synobjs:
const = TracelessXBarTree(synobj).to_constituent()
res.append(const)
return res
else:
return synobjs
