class WhoIs(RegexTemplate): """ Ex: "Who is Tom Cruise?" """ regex = Lemma("who") + Lemma("be") + Person() + \ Question(Pos(".")) def semantics(self, match): definition = DefinitionOf(match.person) return definition, "define"
class ListMoviesRegex(RegexTemplate): """ Ex: "list movies" """ regex = Lemma("list") + (Lemma("movie") | Lemma("film")) def semantics(self, match): movie = IsMovie() name = NameOf(movie) return name, "enum"
class HowOldIsRegex(RegexTemplate): """ Ex: "How old is Bob Dylan". """ regex = Pos("WRB") + Lemma("old") + Lemma("be") + Person() + \ Question(Pos(".")) def semantics(self, match): birth_date = BirthDateOf(match.person) return birth_date, "age"
class FoundationRegex(RegexTemplate): """ Regex for questions about the creation of a band. Ex: "When was Pink Floyd founded?" "When was Korn formed?" """ regex = Pos("WRB") + Lemma("be") + Band() + \ (Lemma("form") | Lemma("found")) + Question(Pos(".")) def semantics(self, match): active_years = ActiveYears(match.band) return active_years, "literal"
class CapitalOfRegex(RegexTemplate): """ Regex for questions about the capital of a country. Ex: "What is the capital of Bolivia?" """ opening = Lemma("what") + Token("is") regex = opening + Pos("DT") + Lemma("capital") + Pos("IN") + \ Question(Pos("DT")) + Country() + Question(Pos(".")) def semantics(self, match): capital = CapitalOf(match.country) label = LabelOf(capital) return label, "enum"
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 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 WhatIs(RegexTemplate): """ Regex for questions like "What is a blowtorch Ex: "What is a car" "What is Seinfield?" """ regex = Lemma("what") + Lemma("be") + Question(Pos("DT")) + \ Thing() + Question(Pos(".")) def semantics(self, match): label = DefinitionOf(match.thing) return label, "define"
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 GenreRegex(RegexTemplate): """ Regex for questions about the genre of a band. Ex: "What is the music genre of Gorillaz?" "Music genre of Radiohead" """ optional_opening = Question(Pos("WP") + Lemma("be") + Pos("DT")) regex = optional_opening + Question(Lemma("music")) + Lemma("genre") + \ Pos("IN") + Band() + Question(Pos(".")) def semantics(self, match): genere = MusicGenereOf(match.band) label = LabelOf(genere) return label, "enum"
class PresidentOfRegex(RegexTemplate): """ Regex for questions about the president of a country. Ex: "Who is the president of Argentina?" """ regex = Lemma("who") + Token("is") + Pos("DT") + Lemma("president") + \ Pos("IN") + Country() + Question(Pos(".")) def semantics(self, match): president = PresidentOf(match.country) incumbent = IncumbentOf(president) label = LabelOf(incumbent) return label, "enum"
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 WhatIs(RegexTemplate): """ Regex for questions like "What is ..." Ex: "What is a car" """ target = Group(Question(Pos("JJ")) + Pos("NN"), "target") regex = Lemma("what") + Lemma("be") + Question(Pos("DT")) + \ target + Question(Pos(".")) def semantics(self, match): target = handle_noun_phrase(match.target) label = DefinitionOf(target) return label, "define"
class WhatTimeIs(RegexTemplate): """ Regex for questions about the time Ex: "What time is in Cordoba" """ nouns = Plus(Pos("NN") | Pos("NNS") | Pos("NNP") | Pos("NNPS")) place = Group(nouns, "place") openings = (Lemma("what") + Lemma("time") + Token("is")) | Lemma("time") regex = openings + Pos("IN") + place + Question(Pos(".")) def semantics(self, match): place = HasKeyword(match.place.lemmas.title()) + IsPlace() utc_offset = UTCof(place) return utc_offset, "time"
class PopulationOfRegex(RegexTemplate): """ Regex for questions about the population of a country. Ex: "What is the population of China?" "How many people live in China?" """ openings = (Pos("WP") + Token("is") + Pos("DT") + Lemma("population") + Pos("IN")) | \ (Pos("WRB") + Lemma("many") + Lemma("people") + Token("live") + Pos("IN")) regex = openings + Question(Pos("DT")) + Country() + Question(Pos(".")) def semantics(self, match): population = PopulationOf(match.country) return population, "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 MoviesByDirectorRegex(RegexTemplate): """ Ex: "List movies directed by Quentin Tarantino. "movies directed by Martin Scorsese" "which movies did Mel Gibson directed" """ regex = (Question(Lemma("list")) + (Lemma("movie") | Lemma("film")) + Question(Lemma("direct")) + Lemma("by") + Director()) | \ (Lemma("which") + (Lemma("movie") | Lemma("film")) + Lemma("do") + Director() + Lemma("direct") + Question(Pos("."))) def semantics(self, match): movie = IsMovie() + DirectedBy(match.director) movie_name = LabelOf(movie) return movie_name, "enum"
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 BandMembersRegex(RegexTemplate): """ Regex for questions about band member. Ex: "Radiohead members" "What are the members of Metallica?" """ regex1 = Band() + Lemma("member") regex2 = Lemma("member") + Pos("IN") + Band() regex3 = Pos("WP") + Lemma("be") + Pos("DT") + Lemma("member") + \ Pos("IN") + Band() regex = (regex1 | regex2 | regex3) + Question(Pos(".")) def semantics(self, match): member = IsMemberOf(match.band) label = LabelOf(member) 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 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 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 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 ActorsOfRegex(RegexTemplate): """ Ex: "who are the actors of Titanic?" "who acted in Alien?" "who starred in Depredator?" "Actors of Fight Club" """ regex = (Lemma("who") + Question(Lemma("be") + Pos("DT")) + (Lemma("act") | Lemma("actor") | Lemma("star")) + Pos("IN") + Movie() + Question(Pos("."))) | \ ((Lemma("actors") | Lemma("actor")) + Pos("IN") + Movie()) def semantics(self, match): actor = NameOf(IsPerson() + StarsIn(match.movie)) return actor, "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") | Lemma("albums")) + \ 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"
class LanguageOfRegex(RegexTemplate): """ Regex for questions about the language spoken in a country. Ex: "What is the language of Argentina?" "what language is spoken in Argentina?" """ openings = (Lemma("what") + Token("is") + Pos("DT") + Question(Lemma("official")) + Lemma("language")) | \ (Lemma("what") + Lemma("language") + Token("is") + Lemma("speak")) regex = openings + Pos("IN") + Question(Pos("DT")) + Country() + \ Question(Pos(".")) def semantics(self, match): language = LanguageOf(match.country) return language, "enum"
class ActedOnRegex(RegexTemplate): """ Ex: "List movies with Hugh Laurie" "Movies with Matt LeBlanc" "In what movies did Jennifer Aniston appear?" "Which movies did Mel Gibson starred?" "Movies starring Winona Ryder" """ acted_on = (Lemma("appear") | Lemma("act") | Lemma("star")) movie = (Lemma("movie") | Lemma("movies") | Lemma("film")) regex = (Question(Lemma("list")) + movie + Lemma("with") + Actor()) | \ (Question(Pos("IN")) + (Lemma("what") | Lemma("which")) + movie + Lemma("do") + Actor() + acted_on + Question(Pos("."))) | \ (Question(Pos("IN")) + Lemma("which") + movie + Lemma("do") + Actor() + acted_on) | \ (Question(Lemma("list")) + movie + Lemma("star") + Actor()) def semantics(self, match): movie = IsMovie() + HasActor(match.actor) movie_name = NameOf(movie) return movie_name, "enum"