def init_form_hierarchy(ch, hierarchies): """ Create the FORM hierarchies associated with the user's choices about verb forms Adds FORM finite and nonfinte values if there are auxiliaries or if user specified """ hier = TDLHierarchy('form') if ch.get('has-aux') == 'yes' or 'noaux-fin-nf' in ch: hier.add('nonfinite', 'form') hier.add('finite', 'form') for p in ('nf', 'fin'): for subform in ch.get(p + '-subform',[]): if p == 'nf': sup = 'nonfinite' elif p == 'fin': sup = 'finite' sub = subform.get('name') hier.add(sub, sup) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_person_hierarchy(ch, hierarchies): hier = TDLHierarchy('person') for p in ch.persons(): for st in p[1].split(';'): hier.add(p[0], st) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_gender_hierarchy(ch, hierarchies): hier = TDLHierarchy('gender') for g in ch.genders(): for st in g[1].split(';'): hier.add(g[0], st) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_pernum_hierarchy(ch, hierarchies): hier = TDLHierarchy('pernum') for pn in ch.pernums(): for st in pn[1].split(';'): hier.add(pn[0], st) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_number_hierarchy(ch, hierarchies): hier = TDLHierarchy('number') for n in ch.numbers(): for st in n[1].split(';'): hier.add(n[0], st) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_situation_hierarchy(ch, hierarchies): hier = TDLHierarchy('situation') for situation in ch.get('situation', []): name = situation.get('name') for supertype in situation.get('supertype', []): supername = supertype.get('name') hier.add(name, supername) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_form_hierarchy(ch, hierarchies): """ Create the FORM hierarchies associated with the user's choices about verb forms """ hier = TDLHierarchy('form') if ('form-fin-nf' in ch): hier.add('nonfinite', 'form') hier.add('finite', 'form') for subform in ch.get('form-subtype', []): hier.add(subform.get('name'), subform.get('supertype')) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_aspect_hierarchy(ch, hierarchies): hier = TDLHierarchy('aspect') for aspect in ch.get('aspect', []): name = aspect.get('name') for supertype in aspect.get('supertype', []): supername = supertype.get('name') hier.add(name, supername) if not hier.is_empty(): hierarchies[hier.name] = hier elif ch.get('perimper'): for asp in ('perfective', 'imperfective'): name = asp supername = 'aspect' hier.add(name, supername) hierarchies[hier.name] = hier
def init_mood_hierarchy(ch, hierarchies): hier = TDLHierarchy('mood') for mood in ch.get('mood', []): name = mood.get('name') for supertype in mood.get('supertype', []): supername = supertype.get('name') hier.add(name, supername) if not hier.is_empty(): hierarchies[hier.name] = hier elif ch.get('subjind'): for md in ('subjunctive', 'indicative'): name = md supername = 'mood' hier.add(name, supername) hierarchies[hier.name] = hier
def init_case_hierarchy(ch, hierarchies): cm = ch.get('case-marking') cases = case_names(ch) hier = TDLHierarchy('case') # For most case patterns, just make a flat hierarchy. For fluid-s, # split-n and split-v, however, a more articulated hierarchy is required. if cm in ['nom-acc', 'erg-abs', 'tripartite', 'split-s', 'focus']: for c in cases: hier.add(c[2], 'case', c[1]) elif cm in ['fluid-s']: abbr = canon_to_abbr('a_case+o_case', cases) for c in cases: if c[0] in ['a_case', 'o_case']: hier.add(c[2], abbr, c[1]) else: hier.add(c[2], 'case', c[1]) elif cm in ['split-n', 'split-v']: nom_a = canon_to_abbr('nom', cases) acc_a = canon_to_abbr('acc', cases) erg_a = canon_to_abbr('erg', cases) abs_a = canon_to_abbr('abs', cases) if cm == 'split-v': for c in cases: hier.add(c[2], 'case', c[1]) else: # 'split-n': hier.add('a_case', 'case', 'transitive agent') hier.add('s_case', 'case', 'intransitive subject') hier.add('o_case', 'case', 'transitive patient') for c in cases: if c[2] == erg_a: hier.add(c[2], 'a_case', c[1]) elif c[2] == nom_a: hier.add(c[2], 'a_case', c[1]) hier.add(c[2], 's_case', c[1]) elif c[2] == abs_a: hier.add(c[2], 's_case', c[1]) hier.add(c[2], 'o_case', c[1]) elif c[2] == acc_a: hier.add(c[2], 'o_case', c[1]) else: hier.add(c[2], 'case', c[1]) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_tense_hierarchy(ch, hierarchies): hier = TDLHierarchy('tense') tdefn = ch.get('tense-definition') if tdefn: if tdefn == 'choose': ppflist = [] for ten in ('nonfuture', 'nonpast', 'past', 'present', 'future'): if ten in ch: if ten not in ppflist: hier.add(ten, 'tense') for subtype in ch.get(ten + '-subtype', []): st = subtype.get('name', '') hier.add(st, ten) if ten == 'nonfuture': for moreten in ('past', 'present'): if moreten in ch: hier.add(moreten, ten) ppflist.append(moreten) if ten == 'nonpast': for moreten in ('present', 'future'): if moreten in ch: hier.add(moreten, ten) ppflist.append(moreten) elif tdefn == 'build': for tense in ch.get('tense', []): name = tense.get('name') for supertype in tense.get('supertype', []): supername = supertype.get('name') hier.add(name, supername) if not hier.is_empty(): hierarchies[hier.name] = hier
def init_other_hierarchies(ch, mylang, hierarchies): for feature in ch.get('feature', []): feat = feature.get('name', '') type = feature.get('type', '') hier = TDLHierarchy(feat, type) if feature.get('new', '') == 'yes': for value in feature.get('value', []): val = value.get('name') for supertype in value.get('supertype', []): stype = supertype.get('name') hier.add(val, stype) else: if type == 'head': mylang.add('head :+ [ ' + feat.upper() + ' ' + feature.get('existing', '') + ' ].', section='addenda') else: mylang.add('png :+ [ ' + feat.upper() + ' ' + feature.get('existing', '') + ' ].', section='addenda') if not hier.is_empty(): hierarchies[hier.name] = hier
def init_case_hierarchy(ch, hierarchies): cm = ch.get('case-marking') cases = case_names(ch) hier = TDLHierarchy('case') # EKN 2018-03-02 If possessive strategy implemented, add an intermediate # level to case hierarchy that contrasts with a 'false' case type that is # assigned to possessors. Keeps possessors from being args of verbs, etc. poss = True if ch.get('poss-strat') or ch.get('poss-pron') else False # For most case patterns, just make a flat hierarchy. For fluid-s, # split-n and split-v, however, a more articulated hierarchy is required. if cm in ['nom-acc', 'erg-abs', 'tripartite', 'split-s', 'focus']: # LTX 2022-04-22: real-case should be only defined once if poss: hier.add('real-case', 'case', 'intermediate case type for all real cases') for c in cases: if poss: hier.add(c[2], 'real-case', c[1]) else: hier.add(c[2], 'case', c[1]) elif cm in ['fluid-s']: if poss: hier.add('real-case', 'case', 'intermediate case type for all real cases') abbr = canon_to_abbr('a_case+o_case', cases) for c in cases: if c[0] in ['a_case', 'o_case']: hier.add(c[2], abbr, c[1]) else: if poss: hier.add(c[2], 'real-case', c[1]) else: hier.add(c[2], 'case', c[1]) elif cm in ['split-n', 'split-v']: if poss: hier.add('real-case', 'case', 'intermediate case type for all real cases') nom_a = canon_to_abbr('nom', cases) acc_a = canon_to_abbr('acc', cases) erg_a = canon_to_abbr('erg', cases) abs_a = canon_to_abbr('abs', cases) if cm == 'split-v': for c in cases: hier.add(c[2], 'case', c[1]) else: # 'split-n': if poss: hier.add('a_case', 'real-case', 'transitive agent') hier.add('s_case', 'real-case', 'intransitive subject') hier.add('o_case', 'real-case', 'transitive patient') else: hier.add('a_case', 'case', 'transitive agent') hier.add('s_case', 'case', 'intransitive subject') hier.add('o_case', 'case', 'transitive patient') for c in cases: if c[2] == erg_a: hier.add(c[2], 'a_case', c[1]) elif c[2] == nom_a: hier.add(c[2], 'a_case', c[1]) hier.add(c[2], 's_case', c[1]) elif c[2] == abs_a: hier.add(c[2], 's_case', c[1]) hier.add(c[2], 'o_case', c[1]) elif c[2] == acc_a: hier.add(c[2], 'o_case', c[1]) else: hier.add(c[2], 'case', c[1]) if not hier.is_empty(): hierarchies[hier.name] = hier
def write_dir_inv_types(choices, mylang, hierarchies): mylang.add('verb :+ [ DIRECTION direction ].', section='addenda') hier = TDLHierarchy('direction') hier.add('dir', 'direction') hier.add('inv', 'direction') hier.save(mylang) if choices.has_SCARGS(): mylang.add('word-or-lexrule :+ [ SC-ARGS list ].', section='addenda') mylang.add('lex-rule :+ [ SC-ARGS #1, DTR.SC-ARGS #1 ].', section='addenda') cases = case.case_names(choices) features = choices.features() # Figure out which features are involved in the hierarchy names = [] # feature names for scale in choices.get('scale', []): for feat in scale.get('feat', []): names.append(feat.get('name', '')) # Now pass through the scale, creating the direct-inverse hierarchy # pairwise mylang.set_section('dirinv') mylang.add_literal(';;; Direct-inverse scale') supertype = 'dir-inv-scale' mylang.add(supertype + ' := canonical-synsem.') scale_len = len(choices.get('scale', '')) for i in range(1, scale_len): values = {} # for each feature, a set of values # get the features on the first scale entry in this range for feat in choices.get('scale')[i].get('feat', []): name = feat.get('name', '') if name not in values: values[name] = set() values[name].add(feat.get('value')) # create the left type in the pair type = 'dir-inv-' + str(i) mylang.add(type + ' := ' + supertype + '.') for n in values: vset = values[n] if n == 'case': new_vset = set() for v in vset: new_vset.add(canon_to_abbr(v, cases)) vset = new_vset geom = '' for f in features: if f[0] == n: geom = f[2] value = hierarchies[n].get_type_covering(vset) if value != n: # don't bother if it doesn't constrain anything mylang.add(type + ' := [ ' + geom + ' ' + value + ' ].') # rest of the scale values = {} for scale in choices.get('scale')[i:]: for feat in scale.get('feat', []): name = feat.get('name', '') if name not in values: values[name] = set() values[name].add(feat.get('value', '')) # create the right type in the pair type = 'dir-inv-non-' + str(i) mylang.add(type + ' := ' + supertype + '.') for n in values: vset = values[n] if n == 'case': new_vset = set() for v in vset: new_vset.add(canon_to_abbr(v, cases)) vset = new_vset geom = '' for f in features: if f[0] == n: geom = f[2] value = hierarchies[n].get_type_covering(vset) if value != n: # don't bother if it doesn't constrain anything mylang.add(type + ' := [ ' + geom + ' ' + value + ' ].') supertype = type # generate subtypes to patch the direct-inverse/unexpressed type conflict mylang.add_literal( ';;; Direct-inverse/unexpressed subtypes for compatibility with argument optionality' ) # add subtypes for each left-branching leaf on the scale for i in range(1, scale_len): type = 'dir-inv-' + str(i) subtype = type + '-unexpressed' mylang.add(subtype + ' := ' + type + ' & unexpressed.') # now add the last, right-branching leaf type = 'dir-inv-non-' + str(scale_len - 1) subtype = type + '-unexpressed' mylang.add(subtype + ' := ' + type + ' & unexpressed.')