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.key 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:
print(entry_base, ['fin', subj_num, 'ter', 'imperf'])
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)