def add_lexrules(choices): ''' ''' for pc in morphotactics.all_position_classes(choices): pc_key = pc.full_key idx = pc['lrt'].next_iter_num() if 'lrt' in pc else 1 for lrt in pc.get('lrt', []): overt = [ f for f in lrt.get('feat', []) if f['name'] == 'overt-arg' ] dropped = [ f for f in lrt.get('feat', []) if f['name'] == 'dropped-arg' ] need_lex_rule = need_no_drop_rule('obj-mark', choices) or \ need_no_drop_rule('subj-mark', choices) # overt-arg morphs should be the index of the next available if overt: feat = overt[0] # convert overt-arg features to OPT if feat['value'] == 'not-permitted': feat['name'] = 'OPT' feat['value'] = 'plus' # only create a lexical rule if necessary if need_lex_rule: key = pc.full_key + '_lrt' + str(idx) name = get_name(pc) + '-no-drop' choices[key + '_name'] = name choices[key + '_feat1_name'] = 'OPT' choices[key + '_feat1_value'] = 'minus' choices[key + '_feat1_head'] = feat['head'] choices[key + '_lri1_inflecting'] = 'no' choices[key + '_lri1_orth'] = '' # dropped-arg morphs should be the index of the next available + 1 if dropped: feat = dropped[0] # convert dropped-arg features to OPT if feat['value'] == 'not-permitted': feat['name'] = 'OPT' feat['value'] = 'minus' # only create a lexical rule if necessary if need_lex_rule: key = pc.full_key + '_lrt' + str(idx + 1) name = get_name(pc) + '-drop' choices[key + '_name'] = name choices[key + '_feat1_name'] = 'OPT' choices[key + '_feat1_value'] = 'plus' choices[key + '_feat1_head'] = feat['head'] choices[key + '_lri1_inflecting'] = 'no' choices[key + '_lri1_orth'] = ''
def get_lt_name(key, choices): if key in LEXICAL_SUPERTYPES: # lexical supertype-- pull out of lexical_supertypes, remove '-lex' return LEXICAL_SUPERTYPES[key].rsplit('-lex', 1)[0] else: # defined lextype, name may or may not be defined name = get_name(choices[key]) lex_st = LEXICAL_SUPERTYPES[key.strip('1234567890')] return '-'.join([name, lex_st.rsplit('-lex', 1)[0]])
def validate(ch, vr): if not ch.get(COMPS): pass matches = {} wo = ch.get(constants.WORD_ORDER) for v in ch.get('verb'): if get_name(v) == 'clausal': vr.err(v.full_key + '_name', "The word 'clausal' is reserved; please use another name.") for ccs in ch.get(COMPS): if wo in ['free', 'v2']: vr.warn(ccs.full_key + '_' + SAME, WO_WARNING) matches[ccs.full_key] = None for vb in ch.get('verb'): val = vb['valence'] if val.endswith(ccs.full_key): matches[ccs.full_key] = vb.full_key for f in vb['feat']: if f['name'] == 'case' and f['head'] == 'obj' and not is_nominalized_complement(ccs): vr.err(f.full_key + '_name', 'You cannot specify case on the object of ' 'a clausal verb unless the complementation strategy involves nominalization.') for m in matches: if not matches[m]: vr.err(ccs.full_key + '_' + SAME, 'You did not enter any verbs in the Lexicon to go with this complementation strategy.') if not (ccs[EXTRA] or ccs[SAME]): vr.err(ccs.full_key + '_' + SAME, SAME_OR_EXTRA) if ccs[EXTRA]: if wo in ['free', 'v2', 'svo', 'vso']: vr.err(ccs.full_key + '_' + EXTRA, EXTRA_VO) for f in ccs['feat']: if f['name'] in ['evidential', 'negation', 'OPT', 'tense']: vr.err(f.full_key + '_name', 'Supported features: aspect, mood, form, nominalization, custom syntactic.') feat = find_in_other_features(f['name'], ch) if feat: if feat['type'] and feat['type'] == 'index': vr.err(f.full_key + '_name', 'Custom semantic features are not supported here.') if ccs['cformvalue'] and not ccs[COMP] == 'oblig': vr.err(ccs.full_key + '_' + COMP, 'FORM on complementizers is only supported with obligatory complementizers.') if ccs['complementizer'] and not (ccs[COMP] == 'oblig' or ccs[COMP] == 'opt'): vr.err(ccs.full_key + '_' + COMP, 'Please choose whether the complementizer is obligatory or optional.')
def add_lexrules(ch): # only need to add rules for mixed_case if not ch.has_mixed_case(): return for pc in ch['noun-pc']: # TJT 2014-09-08: changing to set comprehension for speed #feature_names = {feat['name'] for lrt in pc['lrt'] for feat in lrt['feat']} feature_names = set() for lrt in pc['lrt']: for feat in lrt['feat']: feature_names.add(feat['name']) if 'case' in feature_names: for c in case_names(ch): if ch.has_adp_case(c[0]): idx = ch[pc.full_key + '_lrt'].next_iter_num() lrt_key = pc.full_key + '_lrt' + str(idx) ch[lrt_key + '_name'] = get_name(pc) + '-synth-' + c[0] ch[lrt_key + '_feat1_name'] = 'case' ch[lrt_key + '_feat1_value'] = c[0] ch[lrt_key + '_lri1_inflecting'] = 'no' ch[lrt_key + '_lri1_orth'] = ''
def add_lexrules(ch): # only need to add rules for mixed_case if not ch.has_mixed_case(): return for pc in ch['noun-pc']: # TJT 2014-09-08: changing to set comprehension for speed feature_names = set() for lrt in pc['lrt']: for feat in lrt['feat']: feature_names.add(feat['name']) if 'case' in feature_names: # create a set of cases that can be optionally marked adpositionally # create a new type in the case hierarchy that is a supertype of all these types # make one non inflecting synth rule that sets case to be this new supertype adp_cases = set() cases = case_names(ch) for c in cases: if ch.has_adp_case(c[0]): adp_cases.add(canon_to_abbr(c[0], cases)) # if there were adpositional cases, add the appropriate non-inflecting rule if len(adp_cases) > 0: # find the supertype that covers all the adposition cases if len(adp_cases) == 1: adp_case_name = list(adp_cases)[0] else: for case_supertype in ch['hierarchies']['case'].coverage: if ch['hierarchies']['case'].coverage[ case_supertype] == adp_cases: adp_case_name = case_supertype idx = ch[pc.full_key + '_lrt'].next_iter_num() lrt_key = pc.full_key + '_lrt' + str(idx) ch[lrt_key + '_name'] = get_name(pc) + '-synth-adp' ch[lrt_key + '_feat1_name'] = 'case' ch[lrt_key + '_feat1_value'] = adp_case_name ch[lrt_key + '_lri1_inflecting'] = 'no' ch[lrt_key + '_lri1_orth'] = ''
def add_lexrules(choices): features = choices.features() scale_size = len(choices['scale']) equal = choices.get('scale-equal') for lexprefix in ALL_LEX_TYPES: for lex in choices[lexprefix]: p = lex.full_key n = get_name(lex) if p in ALL_LEX_TYPES: # What does this do and when would it execute? continue l = lexprefix if l == 'det': l = 'determiner' # If the lexical type is a direct-inverse verb, later rules # should use its mandatory rules as input rather than the # lexical type. Create those rules here and put their supertype # in the root_dict. if lexprefix == 'verb' and lex.get('valence').endswith('dirinv'): #direc_geom = [f[2] for f in features if f[0] == 'direction'][0] idx = 1 if 'verb-pc' in choices: idx = choices['verb-pc'].next_iter_num() pc_key = 'verb-pc' + str(idx) choices[pc_key + '_name'] = n + '-dir-inv' choices[pc_key + '_inputs'] = lex.full_key # We also need to reassign PCs that specify lex as an input. reassign_inputs(choices, lex.full_key, pc_key) # The order doesn't really matter for lrules, so just put something choices[pc_key + '_order'] = 'suffix' # make the lexical type require the pc c_idx = 1 if 'require' in lex: c_idx = lex['require'].next_iter_num() c_key = lex.full_key + '_require' + str(c_idx) choices[c_key + '_others'] = pc_key # regarding the calculating of the keys, consider scale_size is 2: # i = 0 or 1, so direc_lrt_key = (0*2)+0+1 = 1, or (1*2)+1+1 = 4 # j = 1 or 2, so lrt_key = (0*2)+0+1+1 = 2, (0*2)+0+2+1 = 3, or # (1*2)+1+1+1 = 5, (1*2)+1+2+1 = 6 for i, direc in enumerate(['dir', 'inv']): direc_lrt_key = pc_key + '_lrt' + str((i * scale_size) + i + 1) choices[direc_lrt_key + '_name'] = '-'.join([n, direc]) choices[direc_lrt_key + '_feat1_name'] = 'direction' choices[direc_lrt_key + '_feat1_value'] = direc for j in range(1, scale_size + 1): if j == scale_size and not (equal == 'direct' and direc == 'dir'): break lrt_key = pc_key + '_lrt' + str((i * scale_size) + i + j + 1) subj_type, comps_type = get_subj_comps_types( j, scale_size, direc, equal) choices[lrt_key + '_name'] = '-'.join( [n, direc, str(j)]) choices[lrt_key + '_supertypes'] = direc_lrt_key choices[lrt_key + '_feat1_name'] = 'dirinv-type' choices[lrt_key + '_feat1_head'] = 'subj' choices[lrt_key + '_feat1_value'] = subj_type choices[lrt_key + '_feat2_name'] = 'dirinv-type' choices[lrt_key + '_feat2_head'] = 'obj' choices[lrt_key + '_feat2_value'] = comps_type # add an empty lexical rule instance choices[lrt_key + '_lri1_inflecting'] = 'no' choices[lrt_key + '_lri1_orth'] = ''
def det_id(item): """Return the identifier for a determiner lexical item.""" return get_name(item) + '-determiner-lex'
def cop_id(item): """Return the identifier for an copula lexical item.""" return get_name(item) + '-cop-lex'
def adj_id(item): """Return the identifier for an adjective lexical item.""" return get_name(item) + '-adj-lex'
def noun_id(item): """Return the identifier for a noun lexical item.""" return get_name(item) + '-noun-lex'
def verb_id(item): """Return the identifier for a verb lexical item.""" return get_name(item) + '-verb-lex'
def find_clausalverb_typename(ch, cs): for v in ch.get(constants.VERB): if v.get(constants.VALENCE).endswith(cs.full_key): name = get_name( v) + '-verb-lex' if not get_name(v).endswith('-verb-lex') else get_name(v) return name