def _capital_query(country, q):
""" Generate answer to question concerning a country capital. """
# Get country code
cc = isocode_for_country_name(country)
if not cc:
logging.warning("No CC for country {0}".format(country))
return False
# Find capital city, given the country code
capital = capital_for_cc(cc)
if not capital:
return False
# Use the Icelandic name for the city
ice_cname = icelandic_city_name(capital["name_ascii"])
# Look up genitive country name for voice description
bres = BIN_Db().lookup_genitive(country, cat="no")
country_gen = bres[0].ordmynd if bres else country
answer = ice_cname
response = dict(answer=answer)
voice = "Höfuðborg {0} er {1}".format(country_gen, answer)
q.set_answer(response, answer, voice)
q.set_key("Höfuðborg {0}".format(country_gen))
q.set_context(dict(subject=ice_cname))
return True
def _addr2nom(address):
""" Convert location name to nominative form """
# TODO: Implement more intelligently
# This is a tad simplistic and mucks up some things,
# e.g. "Ráðhús Reykjavíkur" becomes "Ráðhús Reykjavík"
words = address.split()
nf = []
for w in words:
bin_res = BIN_Db().lookup_nominative(w)
if not bin_res and not w.islower():
# Try lowercase form
bin_res = BIN_Db().lookup_nominative(w.lower())
if bin_res:
nf.append(bin_res[0].ordmynd)
else:
nf.append(w)
return " ".join(nf)
def test_casting():
""" Test functions to cast words in nominative case to other cases """
from reynir.bindb import BIN_Db
db = BIN_Db()
assert db.cast_to_accusative("") == ""
assert db.cast_to_dative("") == ""
assert db.cast_to_genitive("") == ""
assert db.cast_to_accusative("xxx") == "xxx"
assert db.cast_to_dative("xxx") == "xxx"
assert db.cast_to_genitive("xxx") == "xxx"
assert db.cast_to_accusative("maðurinn") == "manninn"
assert db.cast_to_dative("maðurinn") == "manninum"
assert db.cast_to_genitive("maðurinn") == "mannsins"
assert db.cast_to_accusative("mennirnir") == "mennina"
assert db.cast_to_dative("mennirnir") == "mönnunum"
assert db.cast_to_genitive("mennirnir") == "mannanna"
assert db.cast_to_accusative("framkvæma") == "framkvæma"
assert db.cast_to_dative("framkvæma") == "framkvæma"
assert db.cast_to_genitive("framkvæma") == "framkvæma"
assert db.cast_to_accusative("stóru") == "stóru"
assert db.cast_to_dative("stóru") == "stóru"
assert db.cast_to_genitive("stóru") == "stóru"
assert db.cast_to_accusative("stóri") == "stóra"
assert db.cast_to_dative("stóri") == "stóra"
assert db.cast_to_genitive("stóri") == "stóra"
assert db.cast_to_accusative("kattarhestur") == "kattarhest"
assert db.cast_to_dative("kattarhestur") == "kattarhesti"
assert db.cast_to_genitive("kattarhestur") == "kattarhests"
assert db.cast_to_accusative("Kattarhestur") == "Kattarhest"
assert db.cast_to_dative("Kattarhestur") == "Kattarhesti"
assert db.cast_to_genitive("Kattarhestur") == "Kattarhests"
f = lambda mm: [m for m in mm if "2" not in m.beyging]
assert db.cast_to_accusative("fjórir", meaning_filter_func=f) == "fjóra"
assert db.cast_to_dative("fjórir", meaning_filter_func=f) == "fjórum"
assert db.cast_to_genitive("fjórir", meaning_filter_func=f) == "fjögurra"
assert db.cast_to_accusative("Suður-Afríka") == "Suður-Afríku"
assert db.cast_to_dative("Suður-Afríka") == "Suður-Afríku"
assert db.cast_to_genitive("Suður-Afríka") == "Suður-Afríku"
assert db.cast_to_accusative("Vestur-Þýskaland") == "Vestur-Þýskaland"
assert db.cast_to_dative("Vestur-Þýskaland") == "Vestur-Þýskalandi"
assert db.cast_to_genitive("Vestur-Þýskaland") == "Vestur-Þýskalands"
f = lambda mm: sorted(mm, key=lambda m: "2" in m.beyging or "3" in m.beyging)
assert db.cast_to_accusative("Kópavogur", meaning_filter_func=f) == "Kópavog"
assert db.cast_to_dative("Kópavogur", meaning_filter_func=f) == "Kópavogi"
assert db.cast_to_genitive("Kópavogur", meaning_filter_func=f) == "Kópavogs"
def nom2dat(w):
""" Look up the dative form of a noun in BÍN. """
if not w:
return ""
def sort_by_preference(m_list):
""" Discourage rarer declension forms, i.e. ÞGF2 and ÞGF3 """
return sorted(m_list,
key=lambda m: "2" in m.beyging or "3" in m.beyging)
with BIN_Db().get_db() as db:
return db.cast_to_dative(w, meaning_filter_func=sort_by_preference)
def lookup_best_word(word):
""" Look up word in BÍN, pick right one acc. to a criterion. """
with BIN_Db().get_db() as db:
def nouns_only(bin_meaning):
return bin_meaning.ordfl in ("kk", "kvk", "hk")
res = list(filter(nouns_only, db.lookup_nominative(word)))
if not res:
# Try with uppercase first char
capw = word.capitalize()
res = list(filter(nouns_only, db.lookup_nominative(capw)))
if not res:
return None
# OK, we have one or more matching nouns
if len(res) == 1:
m = res[0]
else:
# TODO: Pick best result
m = res[0] # For now
wid = m.utg
# TODO: If more than one declesion form possible (e.g. gen. björns vs. bjarnar)
# we should also list such variations
def sort_by_preference(m_list):
# Filter out words that don't have the same "utg" i.e. word ID as
# the one we successfully looked up in BÍN
mns = list(filter(lambda w: w.utg == wid, m_list))
# Discourage rarer declension forms, i.e. ÞGF2 and ÞGF3
return sorted(m_list,
key=lambda m: "2" in m.beyging or "3" in m.beyging)
# Look up all cases of the word in BÍN
nom = m.stofn
acc = db.cast_to_accusative(nom,
meaning_filter_func=sort_by_preference)
dat = db.cast_to_dative(nom, meaning_filter_func=sort_by_preference)
gen = db.cast_to_genitive(nom, meaning_filter_func=sort_by_preference)
return nom, acc, dat, gen
def handle_plain_text(q):
""" Handle a plain text query, contained in the q parameter
which is an instance of the query.Query class.
Returns True if the query was handled, and in that case
the appropriate properties on the Query instance have
been set, such as the answer and the query type (qtype).
If the query is not recognized, returns False. """
ql = q.query_lower.rstrip("?")
# Timezone being asked about
tz = None
# Whether user asked for the time in a particular location
specific_desc = None
if ql in _TIME_QUERIES:
# Use location to determine time zone
tz = timezone4loc(q.location, fallback="IS")
elif ql.startswith("hvað er klukkan á ") or ql.startswith(
"hvað er klukkan í "):
# Query about the time in a particular location, i.e. country or city
loc = ql[18:] # Cut away question prefix, leaving only placename
# Capitalize each word in country/city name
loc = capitalize_placename(loc)
# Look up nominative
# This only works for single-word city/country names found
# in BÍN and could be improved (e.g. fails for "Nýju Jórvík")
bin_res = BIN_Db().lookup_nominative(loc)
words = [m.stofn for m in bin_res]
words.append(
loc) # In case it's not in BÍN (e.g. "New York", "San José")
# Check if any word is a recognised country or city name
for w in words:
cc = isocode_for_country_name(w)
if cc and cc in country_timezones:
# Look up country timezone
# Use the first timezone although some countries have more than one
# The timezone list returned by pytz is ordered by "dominance"
tz = country_timezones[cc][0]
else:
# It's not a country name, look up in city database
info = lookup_city_info(w)
if info:
top = info[0]
location = (top.get("lat_wgs84"), top.get("long_wgs84"))
tz = timezone4loc(location)
if tz:
# We have a timezone
break
# "Klukkan í Lundúnum er" - Used for voice answer
specific_desc = "{0} er".format(ql[8:])
# Beautify query by capitalizing the country/city name
q.set_beautified_query("{0}{1}?".format(q.beautified_query[:18], loc))
# We have a timezone. Return formatted answer.
if tz:
now = datetime.now(timezone(tz))
desc = specific_desc or "Klukkan er"
# Create displayable answer
answer = "{0:02}:{1:02}".format(now.hour, now.minute)
# A detailed response object is usually a list or a dict
response = dict(answer=answer)
# A voice answer is a plain string that will be
# passed as-is to a voice synthesizer
voice = "{0} {1}:{2:02}.".format(desc, now.hour, now.minute)
q.set_qtype(_TIME_QTYPE)
q.set_key(tz) # Query key is the timezone
q.set_answer(response, answer, voice)
return True
return False
def QGeoSubject(node, params, result):
n = capitalize_placename(result._text)
bin_res = BIN_Db().lookup_nominative(n)
res = bin_res[0].stofn if bin_res else n
result.subject = res
