-
dcz authored
Moving selectional preference popup code from Slowal project. Making some adjustments to database models and API.
0ac4de1b
RealizationDescriptions.py 46.78 KiB
import datetime
import logging
import os
from collections import Counter, defaultdict
from itertools import chain
from shellvalier.settings import BASE_DIR, DEBUG
from meanings.models import LexicalUnit, Synset
from semantics.models import SemanticRole, RoleAttribute
from entries.phrase_descriptions.utils import get_form
from entries.phrase_descriptions.polish_strings import TO
from entries.phrase_descriptions.descriptions import make_phraseologisms
from importer.Phrase import Case, Preposition, Modification, Words, LexPhrase, Fixed, NP, LexNP, LexNumP, PrepNP, LexPrepNP, LexPrepGerP, AdjP, LexAdjP, LexPrepAdjP, PActP, LexPActP
from importer.RealizationDescriptionUtils import *
def get_prefs_list(argument):
return sorted(
map(str, argument.predefined.all())
) + sorted(
map(str, argument.synsets.all())
) + sorted(
map(str, argument.relations.all())
)
LOCATION_ROLES = {'Location', 'Path'}
def select_predefined(predefs):
if len(predefs) == 1:
return predefs[0]
return 'ALL'
# TODO inne heurystyki?
raise RealisationDescriptionError('couldn’t choose predef lemma: {}'.format('/'.join(predefs)))
def select_predefined_for_xp(predefs, role):
if predefs == ['ISTOTY']:
return 'ISTOTY'
return 'ALL'
# TODO heurystyki?
raise RealisationDescriptionError('couldn’t choose predef lemma for XP: {}'.format('/'.join(predefs)))
def get_predefined_lemma(argument, xp=False):
predefined = argument.predefined.all()
if not predefined:
return None
predefs = sorted(p.name for p in predefined)
role = argument.role.role.role
if role not in LOCATION_ROLES and {'LUDZIE', 'PODMIOTY'}.intersection(predefs):
return ['LUDZIE']
if xp:
return [select_predefined_for_xp(predefs, role)]
else:
return [select_predefined(predefs)]
def get_hyponyms(synset, seen=None, tab=' '):
if seen is None:
seen = set()
hyponyms = set()
for hypo in synset.hyponyms.all():
if hypo not in seen:
seen.add(hypo)
hyponyms.add(hypo)
hyponyms.update(get_hyponyms(hypo, seen, tab=tab + ' '))
return hyponyms
# for benchmarking
BENCH3 = defaultdict(list)
# precalculated for the largest ones
HYPONYM_CACHE = {
# sklep-1
4747 : 46,
# obiekt budowlany-1
53426 : 590,
# konstrukcja-1
7218 : 614,
# cecha człowieka-1
36347 : 676,
# aberracja-1 nieprawidłowość-1 zaburzenie-2 zakłócenie-3
4127 : 700,
# znak-1
7416 : 732,
# coś na ząb-1 jedzenie-2 pokarm-1 pożywienie-3 żywność-1
10738 : 766,
# materiał-1 tworzywo-1
1612 : 879,
# jednostka miary-1 jednostka-4 miano-2 miara-3
1161 : 881,
# związek chemiczny-1 związek-1
19589 : 882,
# zjawisko naturalne-1
5351 : 901,
# dzieło-2 praca-6
7469 : 927,
# część-1
462 : 957,
# cecha czynności-1 cecha działania-1
5953 : 1033,
# część-3
104936 : 1056,
# cecha fizyczna-1
5464 : 1056,
# wypowiedź-1
3998 : 1062,
# proces-1
54253 : 1103,
# ciąg wydarzeń-1 ciąg zdarzeń-1
47401 : 1107,
# grupa-2 zespół ludzi-1 zespół-2
7653 : 1176,
# człowiek charakteryzowany ze względu na kwalifikacje-1
6779 : 1188,
# substancja chemiczna-1
5233 : 1206,
# przyrząd-1
7425 : 1260,
# ilość-1
1078 : 1427,
# grupa ludzi-1 grupa-5 ludzie-1
7702 : 1510,
# kategoria-3 pojęcie-2
8170 : 1522,
# urządzenie-5
7446 : 1524,
# historia-3 wydarzenie-1 wypadek-3 zdarzenie-2
6526 : 1533,
# grupa istot-1
103330 : 1585,
# miejsce-1
4750 : 1632,
# stan-1
3243 : 1761,
# narzędzie-1
7610 : 1800,
# roślina-1
4603 : 1928,
# artefakt-1 twór-5 wytwór-2
2605 : 2029,
# człowiek ze względu na swoje zajęcie-1
6797 : 2184,
# nazwa człowieka uwzględniająca jego cechy-1 nosiciel cechy-1
6778 : 2308,
# płód-3 wytwór umysłu-1
8137 : 2599,
# człowiek ze względu na relacje społeczne-1
6775 : 2642,
# fenomen-1 zjawisko-1
5371 : 2674,
# środek-1
28294 : 2793,
# człowiek, który coś robi-1
241977 : 2828,
# substancja-1
5236 : 2871,
# zwierzę-1
5621 : 2966,
# materia-3
247979 : 2970,
# spowodowanie-1 sprawienie-1
102579 : 4255,
# atrybut-1 cecha-1 przymiot-1 własność-2 właściwość-1
323 : 4579,
# grupa-4 zbiór-1
1282 : 4587,
# uczynienie-1 zrobienie-1
102576 : 4851,
# całość-1 ogół-1
2129 : 5668,
# człowiek-1 istota ludzka-1 jednostka-2 osoba-1
6047 : 6151,
# osoba-4
28688 : 6170,
# wytwór-1
2903 : 7230,
# efekt-1 rezultat-1 skutek-1 wynik-1
5195 : 7915,
# przedmiot-1
2646 : 7552,
# istota żywa-1 stworzenie-5 twór-1
6045 : 8448,
# istota-1
1027 : 8536,
# czynność-1
10765 : 8653,
# rzecz-4
103156 : 9480,
# egzemplarz-1 indywiduum-1 jednostka-3 organizm-1 osobnik-2
6731 : 10609,
# obiekt-2
234224 : 21435,
}
def select_synsets(synsets):
by_num_hyponyms = defaultdict(set)
for synset in synsets:
sid = synset.id
if sid not in HYPONYM_CACHE:
#-------
t1 = datetime.datetime.now()
#-------
hyponyms = get_hyponyms(synset)
HYPONYM_CACHE[sid] = len(hyponyms)
#-------
t2 = datetime.datetime.now()
# deciseconds :)
d = round((t2 - t1).total_seconds() * 10)
if DEBUG:
BENCH3[d].append((HYPONYM_CACHE[sid], sid, synset))
# ----
N = HYPONYM_CACHE[sid]
by_num_hyponyms[N].add(synset)
M = max(by_num_hyponyms.keys())
return list(by_num_hyponyms[M])
FREQ = Counter()
with open(os.path.join(BASE_DIR, 'data/freq/sgjp-freq-23032021.tab')) as f:
for l in f:
lemma, pos, freq = l.strip('\n').split('\t')
if pos not in ('adj', 'subst'):
continue
freq = int(freq)
if freq < 10:
continue
# this is inaccurate, but conflate multiple occurrences
FREQ[lemma] += freq
def rank_units(units, ranker):
buckets = defaultdict(set)
for unit in units:
buckets[ranker(unit)].add(unit)
ranked = dict()
for rank, (n, unts) in enumerate(sorted(buckets.items())):
for unit in unts:
ranked[unit] = rank
return ranked
meaning_no_ranker = lambda unit: int(unit.sense)
# TODO lepiej mniej znaczeń (bardziej specyficzne -> precyzyjniejsze?) czy więcej (częstsze -> bardziej zrozumiałe?)
num_meanings_ranker = lambda unit: LexicalUnit.objects.filter(base=unit.base).count()
# w ten sposób nadajemy też najniższy priorytet wielowyrazowym, jeśli istnieje 1-wyrazowa notowana na liście frek.
freq_ranker = lambda unit: -FREQ.get(unit.base, 0)
words_ranker = lambda unit: len(unit.base.split())
# różnice przejrzane oczami na próbce dla:
# [meaning_no_ranker, freq_ranker, num_meanings_ranker]
# [freq_ranker, meaning_no_ranker, num_meanings_ranker] -> [freq_ranker, num_meanings_ranker, meaning_no_ranker] -> takie same wyniki na próbce, TODO sugestia Eli: druga opcja brzmi intuicyjniej
# [num_meanings_ranker, meaning_no_ranker, freq_ranker]
# [meaning_no_ranker, num_meanings_ranker, freq_ranker]
def select_units(units, rankers=[freq_ranker, num_meanings_ranker, meaning_no_ranker, words_ranker]):
units = [unit for unit in units if (unit.base, unit.sense) not in UNIT_KILL_LIST]
unit2rank = defaultdict(lambda: [0 for i in range(len(rankers))])
for i, ranker in enumerate(rankers):
for unit, rank in rank_units(units, ranker).items():
unit2rank[unit][i] = rank
by_rank = defaultdict(set)
for unit, rank in unit2rank.items():
by_rank[tuple(rank)].add(unit)
#for rank, units in sorted(by_rank.items()):
# print(' ***', rank, units)
return sorted(by_rank.items())[0][1]
LEMMA_CACHE = dict()
#returns [lemmata], is_predef
def get_synsets_lemma(argument, pos):
synsets = argument.synsets.filter(lexical_units__pos=pos).distinct()
synsets = [(Synset.objects.get(id=SYNSET_MAP[s.id]) if s.id in SYNSET_MAP else s) for s in synsets if s.id not in SYNSET_KILL_LIST]
if not synsets:
return None
key = tuple(sorted(map(str, synsets)))
if key in LEMMA_CACHE:
return LEMMA_CACHE[key]
synsets = synsets if len(synsets) == 1 else select_synsets(synsets)
for synset in synsets:
if synset.id in SYNSET2LEMMA:
return [SYNSET2LEMMA[synset.id]], True
units = list(chain.from_iterable(synset.lexical_units.all() for synset in synsets))
units = [units[0]] if len(units) == 1 else select_units(units)
ret = (sorted(unit.base for unit in units), False)
if ret[0] == ['cecha czynności', 'cecha działania']:
return (['cecha'], False)
LEMMA_CACHE[key] = ret
return ret
# for benchmarking
BENCH2 = defaultdict(list)
def get_argument_lemma(argument, xp=False):
t1 = datetime.datetime.now()
ret = get_argument_lemma2(argument, xp=xp)
t2 = datetime.datetime.now()
# deciseconds :)
d = round((t2 - t1).total_seconds() * 10)
if DEBUG:
BENCH2[d].append((argument.predefined.all(), argument.synsets.all(), ret))
return ret
def get_argument_lemma2(argument, xp=False):
lemma = get_predefined_lemma(argument, xp=xp)
if lemma:
return lemma, True
lemma = get_synsets_lemma(argument, 'noun')
if lemma:
# get_synsets_lemma returns [lemmata], is_predef
return lemma
lemma = get_synsets_lemma(argument, 'adj')
if lemma:
return lemma
# TODO!!! np. akuratność
return ['ALL'], True
lemma = get_relations_lemma(argument)
assert(lemma)
return lemma, False
# nie powinny występować razem:
# * LUDZIE + PODMIOTY
# * MIEJSCE + OTOCZENIE + POŁOŻENIE
def process_lemma(lemma, phrase_type):
mod = NATR
if lemma in PREDEF2LEMMA:
lemma, gend, num, pos, mod = PREDEF2LEMMA[lemma].get(phrase_type, PREDEF2LEMMA[lemma]['_'])
return lemma, gend, num, pos, mod
if ' ' in lemma:
# eg. ‹środki pieniężne›
words = lemma.split(' ')
tags = []
for i, word in enumerate(words):
tags.append(sorted(get_simplified_tags(word)))
if len(words) == 2 and 'subst:nom' in tags[0] and 'subst:gen' in tags[1]:
# np. ‹dziedzina wiedzy›
lemma = words[0]
mod = make_npgen_mod(words[1])
elif len(words) == 2 and 'subst:nom' in tags[0] and 'adj' in tags[1]:
# np. ‹środki pieniężne›
# ‹napój wyskokowy› -> ‹napój› również impt,
# ‹stan psychiczny› -> ‹psychiczny› również subst,
lemma = words[0]
mod = make_adjp_mod(words[1])
mod._order = 'post'
elif len(words) == 2 and 'subst:nom' in tags[1] and 'adj' in tags[0]:
# np. ‹zły uczynek›
lemma = words[1]
mod = make_adjp_mod(words[0])
elif len(words) == 2 and 'subst:nom' in tags[0] and 'pact' in tags[1]:
# np. ‹pojazd latający›
lemma = words[0]
mod = make_pactp_mod(words[1])
mod._order = 'post'
elif len(words) == 2 and 'subst:nom' in tags[0] and 'ger:gen' in tags[1]:
# np. ‹język programowania›
lemma = words[0]
# nie mamy lexgerp, więc używamy fixed
mod = make_fixed_mod(words[1])
mod._order = 'post'
elif len(words) == 3 and 'subst:nom' in tags[0] and 'prep:gen' in tags[1] and 'subst:gen' in tags[2]:
# np. ‹maszyna do szycia›
lemma = words[0]
mod = make_prepnp_mod(words[2], words[1], 'gen')
else:
raise RealisationDescriptionError('couldn’t parse lemma: {} {}'.format(lemma, tags))
if lemma == 'lata':
return 'rok', 'm3', 'pl', 'subst', mod
if lemma in GERUNDS:
return lemma, 'n', 'sg', 'subst', mod
subst_sg_interps = get_interps(lemma, lemma=lemma, tag_constraints=['subst', 'sg', 'nom'])
if subst_sg_interps:
return lemma, get_gender(subst_sg_interps), 'sg', 'subst', mod
subst_pl_interps = get_interps(lemma, lemma=lemma, tag_constraints=['subst', 'pl', 'nom'])
if subst_pl_interps:
# lemat „mnogi” notowany w Morfeuszu jako plurale tantum, np. ‹środki›
return lemma, get_gender(subst_pl_interps), 'pl', 'subst', mod
pt_interps = get_interps(lemma, tag_constraints=['subst', 'pl', 'nom'])
if pt_interps:
# lemat „mnogi” nie notowany w Morfeuszu, jako plurale tantum, np. ‹pieniądze›
lemmata = set(lemma for lemma, tag in pt_interps)
if len(lemmata) == 1:
return lemmata.pop(), get_gender(pt_interps), 'pl', 'subst', mod
if get_interps(lemma, lemma=lemma, tag_constraints=['adj', 'sg', 'nom', 'm1']):
# przymiotnik
return lemma, None, 'sg', 'adj', mod
ger_interps = get_interps(lemma, tag_constraints=['ger', 'sg', 'nom'])
if ger_interps:
# gerundium
lemmata = set(lemma for lemma, tag in ger_interps)
if len(lemmata) == 1:
return lemmata.pop(), 'n', 'sg', 'ger', mod
raise RealisationDescriptionError('couldn’t process lemma: {} {}'.format(lemma, get_interps(lemma)))
'''
# TODO rodzaj w zależności od hiperonimów?
if lemma == 'członek':
return lemma, 'sg', 'subst', mod
try:
get_form(lemma, ['subst', 'sg', 'nom'])
return lemma, 'sg', 'subst', mod
except:
pass
try:
# lemat „mnogi” notowany w Morfeuszu jako plurale tantum, np. ‹środki›
get_form(lemma, ['subst', 'pl', 'nom'])
return lemma, 'pl', 'subst', mod
except:
pass
try:
# przymiotnik
get_form(lemma, ['adj', 'sg', 'nom', 'm1'])
return lemma, 'sg', 'adj', mod
except:
# lemat „mnogi” nie notowany w Morfeuszu, jako plurale tantum, np. ‹pieniądze›
subst_pl_nom_lemmata = set(interp[2][1].split(':')[0] for interp in morfeusz.analyse(lemma) if interp[2][2].startswith('subst:pl:nom'))
if len(subst_pl_nom_lemmata) == 1:
return subst_pl_nom_lemmata.pop(), 'pl', 'subst', mod
print('============', lemma)
print('============', subst_pl_nom_lemmata)
raise
'''
PREP_2GRAMS = Counter()
with open(os.path.join(BASE_DIR, 'data/freq/2grams_prep_nkjp')) as f:
for l in f:
digram, freq = l.strip('\n').split('\t')
freq = int(freq)
PREP_2GRAMS[digram] = freq
XP2PREPNP = {
'abl' : (('z', 'gen'),),
# do domu / na basen
'adl' : (('do', 'gen'), ('na', 'acc'),),
# w mieście, na wsi, u Janka
'locat' : (('w', 'loc'), ('na', 'loc',), ('u', 'gen'),),
'perl' : (('przez', 'acc'),),
'temp' : (('podczas', 'gen'),),
'dur' : (('przez', 'acc'),),
}
def xp2prepnp(advcat, lemma, num):
if advcat in XP2PREPNP:
preps = XP2PREPNP[advcat]
if len(preps) == 1:
return preps[0]
else:
ranked = []
for prep, case in preps:
form = get_form(lemma, ['subst', num, case])[0]
digram = '{} {}'.format(prep, form)
ranked.append((-PREP_2GRAMS[digram], (prep, case)))
return sorted(ranked)[0][1]
else:
return None, None
XP2COMPREPNP = {
'caus' : 'z powodu',
# TODO: ożywione: dla ..., nieożywione: w celu ...
'dest' : 'w celu',
'instr' : 'za pomocą',
}
def generate_phrases(function, negativity, phrase, lemma, is_predef, head_gender, controller=None, controller_grammar=None):
phrase_type = phrase._name
dummy_id = None
# jak dotąd tylko jeden przypadek zagnieżdżonej frazy lex:
# zależeć: _: : imperf: subj{np(str);ncp(str,int)} + {prepnp(od,gen);prepncp(od,gen,int)} + {xp(mod[comprepnp(na sposób);advp(mod);lex(prepnp(w,acc),sg,'sposób',atr({adjp(agr)}))])}
if isinstance(phrase, LexPhrase):
return make_phraseologisms(phrase, function, negativity, controller=controller, controller_grammar=controller_grammar), None, None
if is_predef and phrase_type == 'xp' and not phrase._category._limitations:
advcat = phrase._category._value
# np. „komuś podobało się gdzieś”
return [PREDEFXP[advcat][lemma]], 'n', 'sg'
distrp = False
processed_lemma, gend, num, pos, mod = process_lemma(lemma, phrase_type)
if phrase_type in ('adjp', 'prepadjp') and pos != 'adj':
# np. aborcja - Manner - lek - adjp(agr)/xp(instr) -> ‹jakaś aborcja›
processed_lemma, gend, pos, mod = 'jakiś', None, 'adj', NATR
if phrase_type == 'nonch':
phrase_type = 'np'
phrase = NP(Case('nom'), dummy_id)
# bo nonch może być realizowana wyłącznie przez ‹coś› itp.
processed_lemma, gend, pos, mod = 'coś', 'n', 'subst', NATR
# i przetwarzanie dalej jako np
if phrase_type == 'distrp':
# ‘po jabłku’ byłoby OK, ale np. ‘po pieniądzach’ brMzmi idiotycznie, więc
# robimy np(gen) i potem dokleimy ‘po ileś’ (czegoś)
distrp = True
phrase_type = 'np'
phrase = NP(Case('gen'), dummy_id)
# i przetwarzanie dalej jako np
#print('PHRASE TYPE:', phrase_type, 'LEMMA:', processed_lemma, 'MODIFICATION:', mod, 'FUNCTION:', function)
words = Words('concat', 'xor', [processed_lemma])
# TODO
if phrase_type in ('cp', 'ncp', 'prepncp'):
cptype = phrase._type._value
assert(cptype in ('int', 'rel') or not phrase._type._realisations)
phr = None
if cptype == 'int':
if phrase._type._realisations:
phr = '/'.join(phrase._type._realisations) + ' …'
else:
phr = 'kto/co/czy/… robi/się dzieje/…'
elif cptype == 'rel':
if phrase._type._realisations:
phr = '/'.join(phrase._type._realisations) + ' …'
else:
phr = 'kto co robi/co się dzieje/…'
elif cptype == 'żeby2':
comp = 'że' if negativity != 'neg' else 'żeby'
phr = 'że coś się stało'
elif cptype in ('żeby', 'jakoby', 'jakby',):
phr = '{} coś się stało'.format(cptype)
elif cptype in ('że', 'bo', 'gdy', 'jak', 'jeśli', 'kiedy',):
phr = '{} coś się dzieje'.format(cptype)
elif cptype in ('aż', 'zanim',):
phr = '{} coś się stanie'.format(cptype)
else:
print(phrase)
1 / 0
if phrase_type == 'cp':
return [phr], 'n', 'sg'
if phrase_type == 'ncp':
return ['{}, {}'.format(TO[phrase._case._value], phr)], 'n', 'sg'
if phrase_type == 'prepncp':
return ['{} {}, {}'.format(phrase._prep._value, TO[phrase._prep._case._value], phr)], 'n', 'sg'
if phrase_type == 'or':
# TODO? absurd „coś się dzieje”? absurd: coś się dzieje?
return ['„coś się dzieje”'], 'n', 'sg'
if phrase_type in ('refl', 'recip'):
# TODO?
return ['się'], None, None
if phrase_type == 'advp':
# TODO!
if pos == 'adj':
return [adj2adv(processed_lemma)], None, None
# dla nie-przymiotników i tak nic nie wymyślimy
return ['jakoś'], None, None
if phrase_type == 'infp':
# TODO?
return ['coś robić' if negativity != 'neg' else 'czegoś robić'], 'n', 'sg'
if phrase_type == 'E':
# TODO?
return ['∅'], 'n', 'sg'
if pos == 'adj' and phrase_type not in ('possp', 'adjp', 'prepadjp',):
# TODO? np. aktualizacja - Manner - automatyczny - xp(instr)
# TODO źle się generuje dla chlastać, ale tam Instrument ma pref. przymiotnikową ‹ostry›, powinno być raczej ‹ostrze›
phrase_type = 'adjp'
phrase = AdjP(Case('agr'), dummy_id)
# i przetwarzanie dalej jako adjp
if phrase_type == 'possp' and processed_lemma == 'czyjś':
return [get_form(processed_lemma, ['sg', 'nom', head_gender, 'pos'])[0]], None, None
if phrase_type == 'comprepnp':
# TODO wielowyrazowe! ‹abonament w wysokości środków pieniężnych›
# TODO może ładniej by było „w czyjejś sprawie”, „na czyjąś rzecz”, ale
# to trochę trudniejsze
return make_comprepnp(phrase._prep._value, words, num, mod), None, None
#return ['{} {}'.format(phrase._prep._value, get_form(lemma, [num, 'gen'])[0])]
lex_phrases = []
phrases = []
if phrase_type == 'np':
# gerundium; TODO? lista wyjątków jeśli więcej
if (processed_lemma, function, phrase._case._value) == ('przyrządzanie', 'subj', 'str'):
return ['przyrządzanie'], 'n', 'sg'
if (processed_lemma, function, phrase._case._value) == ('szarpnięcie', None, 'inst'):
return ['szarpnięciem'], 'n', 'sg'
lex_phrases.append(LexNP(phrase, num, words, mod, dummy_id))
if phrase_type == 'possp':
np = NP(Case('gen'), dummy_id)
lex_phrases.append(LexNP(np, num, words, mod, dummy_id))
if phrase_type == 'prepnp':
# gerundium; TODO? lista wyjątków jeśli więcej
if (processed_lemma, phrase._prep._case._value, phrase._prep._value) == ('przyrządzanie', 'gen', 'do'):
return ['do przyrządzania'], None, None
if phrase._prep._value in ('między', 'pomiędzy', 'wśród', 'pośród') and processed_lemma not in ('ktoś', 'coś'):
num = 'pl'
if pos == 'subst':
lex_phrases.append(LexPrepNP(phrase, num, words, mod, dummy_id))
if pos == 'ger':
lex_phrases.append(LexPrepGerP(phrase, num, 'aff', words, '', mod, dummy_id))
if phrase_type == 'adjp':
# TODO! gender & control
lex_phrases.append(LexAdjP(phrase, 'sg', head_gender if head_gender else 'm1', 'pos', words, mod, dummy_id))
if phrase_type == 'prepadjp':
lex_phrases.append(LexPrepAdjP(phrase, 'sg', 'm1', 'pos', words, mod, dummy_id))
if phrase_type == 'compar':
lex_phrases.append(make_compar(phrase, words, num, mod, controller))
if phrase_type == 'xp':
if phrase._category._limitations:
for realisation in phrase._category._limitations:
phrs, g, n = generate_phrases(function, negativity, realisation, lemma, is_predef, head_gender)
for phr in phrs:
if phr not in phrases:
phrases.append(phr)
return phrases, 'n', 'sg'
else:
advcat = phrase._category._value
if advcat == 'mod':
phrase2 = NP(Case('inst'), dummy_id)
lex_phrases.append(LexNP(phrase2, num, words, mod, dummy_id))
prep, case = xp2prepnp(advcat, processed_lemma, num)
if prep:
phrase2 = PrepNP(Preposition(prep, Case(case)), dummy_id)
lex_phrases.append(LexPrepNP(phrase2, num, words, mod, dummy_id))
if advcat in XP2COMPREPNP:
if pos == 'subst':
comprep = XP2COMPREPNP[advcat]
return make_comprepnp(comprep, words, num, mod), None, None
if pos == 'ger':
assert(mod == NATR)
return ['{} {}'.format(comprep, get_form(processed_lemma, ['ger', num, 'gen', head_gender])[0])], 'n', 'sg'
for lex_phrase in lex_phrases:
for phr in make_phraseologisms(lex_phrase, function, negativity, controller=controller, controller_grammar=controller_grammar):
if phr not in phrases:
# TODO? porządna lista wyjątków, jeśli będzie więcej
if phr == 'na członek rodziny':
phr = 'na członka rodziny'
if distrp:
# po iluś facetów/po ileś dziewczyn/kotów...
phr = 'po {} {}'.format('iluś' if gend == 'm1' else 'ileś', phr)
phrases.append(phr)
assert(phrases)
return phrases, gend if phrase_type == 'np' else None, num if phrase_type == 'np' else None
def get_lex_gender_number(phrase):
if isinstance(phrase, LexNP):
number = phrase._number
# take the first lemma since first expansion is taken for whole meaning description
lemma = phrase._words._lemmas[0]
if lemma == 'siebie':
gender = 'm1'
elif lemma == 'łupień':
gender = 'm2'
else:
interps = get_interps(lemma, lemma=lemma, tag_constraints=['subst', 'nom'])
gender = get_gender(interps)
return gender, number if number != '_' else 'sg'
'''
genders = list()
for lemma in phrase._words._lemmas:
if lemma == 'siebie':
genders.append('m1')
elif lemma == 'łupień':
genders.append('m2')
else:
interps = get_interps(lemma, lemma=lemma, tag_constraints=['subst', 'nom'])
genders.append(get_gender(interps))
return genders[0], number if number != '_' else 'sg'
'''
if isinstance(phrase, LexNumP):
# take the first lemma since first expansion is taken for whole meaning description
lemma = phrase._words._lemmas[0]
interps = get_interps(lemma, lemma=lemma, tag_constraints=['subst', 'nom'])
gender = get_gender(interps)
lemma = phrase._nums._lemmas[0]
recs = set()
if lemma == '2':
recs.add('congr')
else:
for interp in get_interps(lemma, lemma=lemma, tag_constraints=['num', 'nom']):
recs.add(interp[1].split(':')[-1])
assert(len(recs) == 1)
rec = recs.pop()
if rec == 'rec':
# wiele/pięciu/trzydzieści osiem kotów/facetów/kobiet przyszło
return 'n', 'sg'
else:
# trzy kobiety/koty przyszły/trzej faceci przyszli
return gender, 'pl'
return None, None
PHRASE_CACHE = dict()
PHRASE_SEP = ' / '
# for benchmarking
BENCH = defaultdict(list)
def get_phrase_description(subentry, argument, position, phrase, controller_grammar=None):
t1 = datetime.datetime.now()
ret = get_phrase_description2(subentry, argument, position, phrase, controller_grammar=controller_grammar)
t2 = datetime.datetime.now()
# deciseconds :)
d = round((t2 - t1).total_seconds() * 10)
if DEBUG:
BENCH[d].append((subentry.entry.name, argument.role.role.role, ret[0]))
return ret
# subentry, argument: DB model objects
# schema, phrase: importer objects
def get_phrase_description2(subentry, argument, position, phrase, controller_grammar=None):
#print()
#print(argument)
#print(phrase)
gender, number = None, None
function = position._function._value if position._function else None
control = None
if position._control:
#assert(len(position._control) == 1)
#control = position._control[0]._function
ee = [c._function for c in position._control if c._function.endswith('controllee')]
er = [c._function for c in position._control if c._function.endswith('controller')]
assert(len(ee) <= 1)
assert(len(er) <= 1)
# e.g. ‹uznać› — controllee and pred_controller on the same position, take controllee
if ee:
control = ee[0]
else:
control = er[0]
negativity = subentry.negativity.name if subentry.negativity else '_'
head_lemma, head_gender = subentry.entry.name, None
controller, controller_features, controller_function = None, None, None
if control and control.endswith('controllee'):
controller = position._schema.getController(control)
try:
controller_features = controller_grammar[controller]
except KeyError:
controller_features = ('m1', 'sg')
logging.warning('{} couldn’t determine grammar features for {}: {} {}; assuming m1 sg'.format(subentry.entry.name, ' '.join(map(str, argument.frame.lexical_units.all())), control, phrase))
controller_function = controller._function._value if controller._function else None
if subentry.entry.pos.tag == 'noun':
interps = get_interps(head_lemma, lemma=head_lemma, tag_constraints=['subst', 'nom'])
head_gender = get_gender(interps)
# TODO
# TODO gender, number
# TODO (‹jakieś›) oko * (‹jakieś›) oczy *błyszczy* z powodu substancji
if isinstance(phrase, LexPhrase) or isinstance(phrase, Fixed):
phrs = []
# TODO to powinny być tylko brakujące [...] w lex(cp)
try:
for phr in make_phraseologisms(phrase, function, negativity, controller=controller, controller_grammar=controller_features):
if phr not in phrs:
phrs.append(phr)
except:
phrs.append('!!!???')
gender, number = get_lex_gender_number(phrase)
return PHRASE_SEP.join(phrs), gender, number
lemmata, is_predef = get_argument_lemma(argument, xp=(phrase._name == 'xp' and not phrase._category._limitations))
if len(lemmata) != 1:
raise RealisationDescriptionError('couldn’t choose single lemma: {}'.format('/'.join(lemmata)))
phrases = []
# TODO since there’s one lemma, drop the loop
for lemma in lemmata:
key = (function, negativity, str(phrase), lemma, str(head_gender), control, controller_features, controller_function)
if key in PHRASE_CACHE:
lemma_phrases, gender, number = PHRASE_CACHE[key]
else:
lemma_phrases, gender, number = generate_phrases(function, negativity, phrase, lemma, is_predef, head_gender, controller=controller, controller_grammar=controller_features)
PHRASE_CACHE[key] = (lemma_phrases, gender, number)
phrases += lemma_phrases
return PHRASE_SEP.join(phrases), gender, number
def get_only_value(d):
return list(d.values())[0]
PRIORITY, ATTR, SUBPRIORITY = 'priority', 'attr', 'subpriority'
LOW_PRIORITY = 200
CP_PRIO = {
'żeby' : 0, # że
'kiedy' : 0, # gdy, jak
'żeby2' : 1, # jak
'że' : 2, # jak
# prefer phrases introduced by complementisers where present
'int' : LOW_PRIORITY + 1,
}
PHRASE_PRIORITY = {
'xp' : {
PRIORITY : 10,
ATTR : lambda phrase: phrase._category._value,
SUBPRIORITY : {
'adl' : 0, # nawigacja xp(adl)/xp(locat)
'locat' : 1, # powycierać xp(abl)/xp(locat)
'caus' : 2, # ucierpieć xp(caus)/xp(temp)
},
},
'np' : {
PRIORITY : 20,
ATTR : lambda phrase: phrase._case._value,
SUBPRIORITY : {
'str' : 0,
},
},
'prepnp' : {
PRIORITY : 22,
ATTR : lambda phrase: (phrase._prep._value, phrase._prep._case._value),
SUBPRIORITY : {
('do', 'gen') : 0, # adekwatny do/dla; kolejka do/za
('za', 'inst') : 1, # agitować za/przeciw
('o', 'acc') : 1, # apel o/przeciw
('w', 'acc') : 1, # całować w/po
('w', 'loc') : 1, # defilada w/na pojeździe
('między', 'inst') : 2, # debata między/z/wśród
('o', 'loc') : 2, # debata o/wokół/nad
('wobec', 'gen') : 2, # dług wobec/względem, konsekwentny wobec/dla
('dla', 'gen') : 3, # certyfikat dla/za
('z', 'gen') : 2, # dochód z/za/od
('o', 'acc') : 3, # kampania o/za
('pod', 'inst') : 4, # kruszyć się pod/od
('o', 'loc') : 4, # książka o czymś/z czegoś
('po', 'loc') : 5, # odlatywać od/po
('od', 'gen') : 6, # podatek od/za
('przeciw', 'dat') : 7, # przestępstwo z/przeciw
('na', 'loc') : 7, # skoncentrować się na/nad
('za', 'acc') : 7, # zabulić na/za
('z', 'acc') : LOW_PRIORITY + 1, # mandat – błąd w danych, jest tam też za:acc
},
},
'comprepnp' : {
PRIORITY : 24,
ATTR : lambda phrase: phrase._prep._value,
SUBPRIORITY : {
'w sprawie' : 0, # w kwestii
'w zakresie' : 0, # dyletant w zakresie/w kwestii
'w kwestii' : 1, # dyskrecja co do/w kwestii
'z dziedziny' : 1, # referat w dziedzinie/z dziedziny
},
},
'cp' : {
PRIORITY : 30,
ATTR : lambda phrase: phrase._type._value,
SUBPRIORITY : CP_PRIO,
},
'ncp' : {
PRIORITY : 32,
ATTR : lambda phrase: phrase._type._value,
SUBPRIORITY : CP_PRIO,
},
'prepncp' : {
PRIORITY : 34,
ATTR : lambda phrase: phrase._type._value,
SUBPRIORITY : CP_PRIO,
},
}
def get_phrase_priority(phrase):
lex = False
if isinstance(phrase, LexPhrase):
lex = True
phrase = phrase._lex_phrase()
phrase_type = phrase._name
if phrase_type == 'xp' and phrase._category._limitations:
# TODO? heurystyka: bierzemy pierwszą
phrase, phrase_type = phrase._category._limitations[0], phrase._category._limitations[0]._name
if phrase_type not in PHRASE_PRIORITY:
return (LOW_PRIORITY, LOW_PRIORITY)
attr = PHRASE_PRIORITY[phrase_type][ATTR](phrase)
# lower the priority by 1 for lexes, eg. dostępność prepnp(dla, gen)/lex(prepnp(‹dla kieszeni›))
return (PHRASE_PRIORITY[phrase_type][PRIORITY] + (1 if lex else 0), PHRASE_PRIORITY[phrase_type][SUBPRIORITY].get(attr, LOW_PRIORITY))
# position: importer object
# phrase_descriptions: dict
# key: phrase importer object
# value: (description, gender, number)
# result: phrase description to use in the realisation description
def select_phrase_description(position, phrase_descriptions):
#print(type(position))
#print(phrase_descriptions)
if len(phrase_descriptions) == 1:
desc = get_only_value(phrase_descriptions)
assert(desc[0] != '???')
return desc
by_priority = defaultdict(set)
for p, d in phrase_descriptions.items():
by_priority[get_phrase_priority(p)].add((p, d))
min_priority_phrases = by_priority[min(by_priority.keys())]
if len(min_priority_phrases) == 1:
p, desc = min_priority_phrases.pop()
assert (desc[0] != '???')
return desc
else:
# all are lex phrases
assert(all(isinstance(p, LexPhrase) for p, d in min_priority_phrases))
# all have the same grammatical type
assert(len(set(str(p._lex_phrase()) for p, d in min_priority_phrases)) == 1)
# heuristic: return first lexicographically
return sorted(min_priority_phrases, key=lambda x: x[1][0])[0][1]
#raise RealisationDescriptionError('couldn’t select phrase description: {}'.format(' * '.join(desc[0] for desc in phrase_descriptions.values())))
FUNCTION_RANK = {
'subj' : 0,
'head' : 0,
'obj' : 2,
None : 4,
}
def is_np(phrase, case):
if phrase._name != 'np':
return False
if isinstance(phrase, LexPhrase):
return phrase._np._case._value == case
else:
return phrase._case._value == case
# TODO: possp na początku tylko, jeśli jest przymiotnikowe
def get_argument_realisation_priority(ar, entry_pos):
position = ar._position
function = position._function._value if position._function else None
# first rank by subj or possp, obj, rest
rank1 = FUNCTION_RANK[function]
phrase_types = set(phrase._name for phrase in position._phrases)
if (phrase_types == {'adjp'} and entry_pos == 'noun') or phrase_types == {'possp'}:
# jakieś COŚ, ale UCZYNIĆ kogoś jakimś
rank1 = 0
# np(dat) after verb ‹ktoś daje komuś coś›
if [p for p in ar._position._phrases if is_np(p, 'dat')]:
rank1 = 1
# np(str) without function (TODO? error in data, e.g. chwytać ustami *powietrze* – should be obj?)
if function is None and [p for p in ar._position._phrases if is_np(p, 'str')]:
rank1 = 3
# clauses at the end
if {'cp', 'ncp', 'prepncp'}.issuperset(phrase_types):
rank1 = 5
# then rank by phrase type: refl/recip, then nominal, then rest
rank2 = 2
if {'refl', 'recip'}.intersection(phrase_types):
rank2 = 0
elif 'np' in phrase_types:
rank2 = 1
# finally rank by semantic argument priority
sem_role = ar._argument._semantic_role
role_prio = SemanticRole.objects.get(role=sem_role._value).priority
attribute_prio = RoleAttribute.objects.get(attribute=sem_role._attribute).priority if sem_role._attribute else 0
rank3 = (role_prio, attribute_prio)
return [rank1, rank2, rank3]
# jeśli nie ma nic na początku, a jest np(dat), to przesuwamy na początek
def rerank(ars):
#print(ars)
before, after, np_dat = [], [], []
for rank, fallback, ar in ars:
if rank[0] == 0:
before.append((rank, fallback, ar))
elif [p for p in ar._position._phrases if is_np(p, 'dat')]:
np_dat.append((rank, fallback, ar))
else:
after.append((rank, fallback, ar))
if before:
return ars
else:
#assert(len(np_dat) <= 1) #TODO? hasło: daleki
return [([0] + rank[1:], fallback, ar) for rank, fallback, ar in np_dat] + after
# for multi-position Lemma arguments, e.g. dostać się z deszczu pod rynnę
FALLBACK = {
'z deszczu' : 1,
'pod rynnę' : 2,
'od ściany' : 1,
'do ściany' : 2,
'żywcem' : 1,
'ze skóry' : 2,
'pięknym' : 1,
'za nadobne' : 2,
'od Annasza' : 1,
'do Kajfasza' : 2,
'z (brudnymi) buciorami / z (swoimi) buciorami / z (brudnymi swoimi) buciorami / z (brudnymi) butami / z (swoimi) butami / z (brudnymi swoimi) butami' : 1,
'do łóżka / do łóżek' : 2,
'samego' : 1,
'w (‹jakieś›) ręce' : 2,
'z (‹jakiejś›) radości / z (‹jakiegoś›) szczęścia' : 1,
'pod sufit' : 2,
'z jednej skrajności' : 1,
'w drugą' : 2,
'ze skrajności' : 1,
'w skrajność' : 2,
'z motyką' : 1,
'na słońce' : 2,
'z nogi' : 1,
'na nogę' : 2,
'z pustego' : 1,
'w próżne' : 2,
'z (‹jakiejś›) klasy' : 1,
'do (‹jakiejś›) klasy' : 2,
'z (‹jakiegoś›) kwiatka' : 1,
'na (‹jakiś›) kwiatek' : 2,
'w dno' : 1,
'od spodu' : 2,
'po rozum' : 1,
'do głowy' : 2,
'z pazurami / z pięściami' : 1,
'do oczu' : 2,
'na ziemię' : 1,
'z obłoków' : 2,
'prosto' : 1,
'w (‹jakieś›) serce / w (‹jakieś›) serca' : 2,
'z rąk' : 1,
'do rąk' : 2,
'z ręki' : 1,
'do ręki' : 2,
'o pomstę' : 1,
'do nieba' : 2,
'ze zbiornika' : 1,
'do zbiornika' : 2,
'samo' : 1,
'do (‹jakiejś›) ręki / do (‹jakichś›) rąk' : 2,
'sama' : 1,
'w (moje/pańskie/Anny/…) (‹jakieś›) ręce' : 2,
'sam' : 1,
'przed (moje/pańskie/Anny/…) (‹jakieś›) oczy' : 2,
'sama' : 1,
'do (mojej/pańskiej/Anny/…) (‹jakiejś›) ręki / do (moich/pańskich/Anny/…) (‹jakichś›) rąk' : 2,
}
def fallback(description):
return FALLBACK.get(description, 0)
WINIEN = ('powinien', 'winien',)
# realisation: importer object
# subentry: DB model object
# TODO wszystkie lex-y chyba powinny wejść do tej reprezentacji,
# np. ktoś babrze ‹sobie› ‹rączki›: ‹sobie› nie jest powiązane z argumentem...
def get_realisation_description(realisation, subentry, aspect):
entry = subentry.entry
ars = [(get_argument_realisation_priority(ar, entry.pos.tag), fallback(ar._description), ar) for ar in realisation._argument_realizations]
#print([(p1, p2, ar._description) for p1, p2, ar in ars])
try:
ars = sorted(ars)
except:
raise RealisationDescriptionError('couldn’t order argument realisations: {}'.format(' * '.join('{}{} {}'.format(ar._argument._semantic_role._value, ar._argument._semantic_role._attribute, ar._description) for ar in realisation._argument_realizations)))
if entry.pos.tag == 'verb':
# dla innych nie przesuwamy np(dat): bliski *komuś*
ars = rerank(ars)
before = [('<b>{}</b>' if ar._argument._semantic_role._value == 'Lemma' else '{}').format(ar._description.split(PHRASE_SEP)[0]) for rank, fallback, ar in ars if rank[0] == 0]
after = [('<b>{}</b>' if ar._argument._semantic_role._value == 'Lemma' else '{}').format(ar._description.split(PHRASE_SEP)[0]) for rank, fallback, ar in ars if rank[0] > 0]
subj_ars = [ar for ar in realisation._argument_realizations if ar._position._function and ar._position._function._value == 'subj']
if len(subj_ars) > 1:
raise RealisationDescriptionError('> 1 subject argument realisations: {}'.format(' * '.join('{}{} {}'.format(ar._argument._semantic_role._value, ar._argument._semantic_role._attribute, ar._description) for ar in subj_ars)))
subj_ar = subj_ars[0] if subj_ars else None
head_ars = [ar for ar in realisation._argument_realizations if ar._position._function and ar._position._function._value == 'head']
if len(head_ars) > 1:
raise RealisationDescriptionError('> 1 head argument realisations: {}'.format(' * '.join('{}{} {}'.format(ar._argument._semantic_role._value, ar._argument._semantic_role._attribute, ar._description) for ar in head_ars)))
head_ar = head_ars[0] if head_ars else None
entry_form = entry.name
if entry.name == 'naleźć':
#TODO błąd w słowniku
aspect = 'perf'
if entry.pos.tag == 'adj' and head_ar:
entry_form = get_form(entry.name, ['adj', head_ar._number, 'nom', head_ar._gender, 'pos'])[0]
elif entry.name == 'bootować':
# nienotowane w Morfeuszu
entry_form = 'bootuje'
elif entry.name == 'wtyczkować':
# nienotowane w Morfeuszu
entry_form = 'wtyczkuje'
elif entry.pos.tag == 'verb':
assert(aspect)
entry_base = entry.name
if entry_base == 'doprząc':
entry_base = 'doprzęgnąć'
if aspect == '_':
# eg. aresztować
aspect = 'imperf'
try:
subj_num = subj_ar._number if subj_ar else 'sg'
if subj_ar and (aspect == 'perf' or entry_base in WINIEN):
# potrzebne tylko dla dokonanych (zrobił/a/o) i winien/na
if subj_ar._gender:
subj_gend = subj_ar._gender
else:
raise RealisationDescriptionError('couldn’t determine subject’s gender: {} {} {}'.format(subj_ar, subj_ar._position._phrases, subj_ar._argument))
else:
# no subject: ‹jestem kotem — olśniło kogoś›
subj_gend = 'n'
if entry_base in WINIEN:
entry_form = get_form(entry_base, ['winien', subj_num, subj_gend, 'imperf'])[0]
elif aspect == 'imperf':
# niedokonane: fin (cz. teraźnieszy)
# TODO? lista wyjątków, jeśli będzie więcej
if entry_base == 'sparować' and subj_num == 'sg':
# bokser sparuje — imperf nienotowane w Morfeuszu
entry_form = 'sparuje'
else:
entry_form = get_form(entry_base, ['fin', subj_num, 'ter', 'imperf'])[0]
else:
# dokonane: praet (cz. przeszły)
# TODO? lista wyjątków, jeśli będzie więcej
if entry_base == 'nasuwać' and (subj_num, subj_gend) == ('sg', 'm1'):
# „Nasuwał się mebli przy odnawianiu mieszkania.” — perf nienotowane w Morfeuszu
entry_form = 'nasuwał'
elif entry_base == 'wybzykać' and (subj_num, subj_gend) == ('sg', 'm1'):
# nienotowane w Morfeuszu
entry_form = 'wybzykał'
elif entry_base == 'wytuszować' and (subj_num, subj_gend) == ('sg', 'm1'):
# nienotowane w Morfeuszu
entry_form = 'wytuszował'
elif entry_base == 'zależeć' and (subj_num, subj_gend) == ('sg', 'm2'):
# nienotowane w Morfeuszu
entry_form = 'zależał'
elif entry_base == 'zemdlić' and (subj_num, subj_gend) == ('sg', 'f'):
# formy inne niż „zemdliło” nienotowane w Morfeuszu
entry_form = 'zemdliła'
else:
entry_form = get_form(entry_base, ['praet', subj_num, subj_gend, 'perf', ['nagl', '']])[0]
except:
entry_form = get_form(entry_base, ['pred'])[0]
if entry.name == 'napaść' and {'wal_69620-mng', 'wal_80242-mng', 'wal_174604-mng', 'wal_174605-mng', 'wal_174603-mng', 'wal_174606-mng'}.issuperset(realisation._frame._meanings):
# znaczenie ‹napaść (się) jedzeniem›
entry_form = entry_form.replace('dł', 'sł')
if entry.name == 'oblec' and {'wal_85605-mng', 'wal_85615-mng'}.issuperset(realisation._frame._meanings):
# znaczenie ‹oblec twierdzę›
entry_form = entry_form.replace('kł', 'gł')
if entry.name == 'odpaść' and {'wal_68230-mng', 'wal_68225-mng', 'wal_79689-mng'}.issuperset(realisation._frame._meanings):
# znaczenie ‹odpaść (się) jedzeniem›
entry_form = entry_form.replace('dł', 'sł')
if entry.name == 'podpaść' and {'wal_86356-mng', 'wal_86350-mng', 'wal_174582-mng', 'wal_174584-mng', 'wal_174585-mng', 'wal_174586-mng'}.issuperset(realisation._frame._meanings):
# znaczenie ‹podpaść (się) jedzeniem›
entry_form = entry_form.replace('dł', 'sł')
if entry.name == 'popaść' and {'wal_174529-mng', 'wal_174530-mng'}.issuperset(realisation._frame._meanings):
# znaczenie ‹popaść (się) jedzeniem›
entry_form = entry_form.replace('dł', 'sł')
if subentry.negativity and subentry.negativity.name == 'neg':
entry_form = 'nie ' + entry_form
if subentry.inherent_sie.name == 'true':
entry_form += ' się'
elements = before + ['<b>{}</b>'.format(entry_form)] + after
if entry_form[0] > 'z':
#-------
for t in sorted(BENCH3.keys()):
if t > 4:
print(' ************', t, len(BENCH3[t]), BENCH3[t][:10])
for n, sid, synset in BENCH3[t]:
print(' ************', synset)
print(' ************', sid, ':', n)
#for t in sorted(BENCH2.keys()):
# if t > 4:
# print(' ********', t, len(BENCH2[t]), BENCH2[t][:10])
#for t in sorted(BENCH.keys()):
# if t > 4:
# print(' ****', t, len(BENCH[t]), BENCH[t][:10])
#-------
return ' '.join(elements)