class WhoWroteRegex(RegexTemplate):
"""
Ex: "who wrote The Little Prince?"
"who is the author of A Game Of Thrones?"
"""
regex = ((Lemmas("who write") + Book()) |
(Question(Lemmas("who be") + Pos("DT")) +
Lemma("author") + Pos("IN") + Book())) + \
Question(Pos("."))
def semantics(self, match):
author = NameOf(IsPerson() + AuthorOf(match.book))
return author, "literal"
class BooksByAuthorRegex(RegexTemplate):
"""
Ex: "list books by George R. R. Martin"
"which books did Suzanne Collins wrote?"
"""
regex = (Question(Lemma("list")) + Lemmas("book by") + Author()) | \
((Lemma("which") | Lemma("what")) + Lemmas("book do") +
Author() + Lemma("write") + Question(Pos(".")))
def semantics(self, match):
book = IsBook() + HasAuthor(match.author)
book_name = NameOf(book)
return book_name, "enum"
class PlotOfRegex(RegexTemplate):
"""
Ex: "what is Shame about?"
"plot of Titanic"
"""
regex = ((Lemmas("what be") + Movie() + Lemma("about")) | \
(Question(Lemmas("what be the")) + Lemma("plot") +
Pos("IN") + Movie()) +
Question(Pos(".")))
def semantics(self, match):
definition = DefinitionOf(match.movie)
return definition, "define"
class MovieDurationRegex(RegexTemplate):
"""
Ex: "How long is Pulp Fiction"
"What is the duration of The Thin Red Line?"
"""
regex = ((Lemmas("how long be") + Movie()) |
(Lemmas("what be") + Pos("DT") + Lemma("duration") +
Pos("IN") + Movie())) + \
Question(Pos("."))
def semantics(self, match):
duration = DurationOf(match.movie)
return duration, ("literal", "{} minutes long")
class ShowsWithRegex(RegexTemplate):
"""
Ex: "List shows with Hugh Laurie"
"In what shows does Jennifer Aniston appears?"
"Shows with Matt LeBlanc"
"""
regex = (Lemmas("list show") + Pos("IN") + Actor()) | \
(Pos("IN") + Lemmas("what show do") +
Actor() + (Lemma("appear") | Lemma("work")) +
Question(Pos("."))) | \
((Lemma("show") | Lemma("shows")) + Pos("IN") + Actor())
def semantics(self, match):
show = IsTvShow() + HasActor(match.actor)
show_name = ShowNameOf(show)
return show_name, "enum"
class CastOfRegex(RegexTemplate):
"""
Ex: "What is the cast of Friends?"
"Who works in Breaking Bad?"
"List actors of Seinfeld"
"""
regex = (Question(Lemmas("what be") + Pos("DT")) +
Lemma("cast") + Pos("IN") + TvShow() + Question(Pos("."))) | \
(Lemmas("who works") + Pos("IN") + TvShow() +
Question(Pos("."))) | \
(Lemmas("list actor") + Pos("IN") + TvShow())
def semantics(self, match):
actor = IsPerson() + StarsIn(match.tvshow)
name = LabelOf(actor)
return name, "enum"
class ListTvShows(RegexTemplate):
"""
Ex: "List TV shows"
"""
regex = Lemmas("list tv show")
def semantics(self, match):
show = IsTvShow()
label = LabelOf(show)
return label, "enum"
class ReleaseDateRegex(RegexTemplate):
"""
Ex: when was Friends release?
"""
regex = Lemmas("when be") + TvShow() + Lemma("release") + \
Question(Pos("."))
def semantics(self, match):
release_date = ReleaseDateOf(match.tvshow)
return release_date, "literal"
class CreatorOfRegex(RegexTemplate):
"""
Ex: "Who is the creator of Breaking Bad?"
"""
regex = Question(Lemmas("who be") + Pos("DT")) + \
Lemma("creator") + Pos("IN") + TvShow() + Question(Pos("."))
def semantics(self, match):
creator = CreatorOf(match.tvshow)
label = LabelOf(creator)
return label, "enum"
class WhereIsFromRegex(RegexTemplate):
"""
Ex: "Where is Bill Gates from?"
"""
regex = Lemmas("where be") + Person() + Lemma("from") + \
Question(Pos("."))
def semantics(self, match):
birth_place = BirthPlaceOf(match.person)
label = LabelOf(birth_place)
return label, "enum"
class EpisodeCountRegex(RegexTemplate):
"""
Ex: "How many episodes does Seinfeld have?"
"Number of episodes of Seinfeld"
"""
regex = ((Lemmas("how many episode do") + TvShow() + Lemma("have")) |
(Lemma("number") + Pos("IN") + Lemma("episode") +
Pos("IN") + TvShow())) + \
Question(Pos("."))
def semantics(self, match):
number_of_episodes = NumberOfEpisodesIn(match.tvshow)
return number_of_episodes, "literal"
class MovieReleaseDateRegex(RegexTemplate):
"""
Ex: "When was The Red Thin Line released?"
"Release date of The Empire Strikes Back"
"""
regex = ((Lemmas("when be") + Movie() + Lemma("release")) |
(Lemma("release") + Question(Lemma("date")) +
Pos("IN") + Movie())) + \
Question(Pos("."))
def semantics(self, match):
release_date = ReleaseDateOf(match.movie)
return release_date, "literal"
class DirectorOfRegex(RegexTemplate):
"""
Ex: "Who is the director of Big Fish?"
"who directed Pocahontas?"
"""
regex = ((Lemmas("who be") + Pos("DT") + Lemma("director") +
Pos("IN") + Movie()) |
(Lemma("who") + Lemma("direct") + Movie())) + \
Question(Pos("."))
def semantics(self, match):
director = IsPerson() + DirectorOf(match.movie)
director_name = NameOf(director)
return director_name, "literal"
class WhereIsRegex(RegexTemplate):
"""
Ex: "where in the world is the Eiffel Tower"
"""
thing = Group(Plus(Pos("IN") | Pos("NP") | Pos("NNP") | Pos("NNPS")),
"thing")
regex = Lemma("where") + Question(Lemmas("in the world")) + Lemma("be") + \
Question(Pos("DT")) + thing + Question(Pos("."))
def semantics(self, match):
thing = HasKeyword(match.thing.tokens)
location = LocationOf(thing)
location_name = LabelOf(location)
return location_name, "enum"
class AlbumsOfRegex(RegexTemplate):
"""
Ex: "List albums of Pink Floyd"
"What albums did Pearl Jam record?"
"Albums by Metallica"
"""
regex = (Question(Lemma("list")) + Lemma("album") + Pos("IN") + Band()) | \
(Lemmas("what album do") + Band() +
(Lemma("record") | Lemma("make")) + Question(Pos("."))) | \
(Lemma("list") + Band() + Lemma("album"))
def semantics(self, match):
album = IsAlbum() + ProducedBy(match.band)
name = NameOf(album)
return name, "enum"
