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 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 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 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 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 PresidentOfRegex(RegexTemplate): """ Regex for questions about the president of a country. Ex: "Who is the president of Argentina?" """ regex = Pos("WP") + Token("is") + Question(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 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 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 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 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"
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 ListEntity(RegexTemplate): """ Regex for questions like "List Microsoft software" """ entity = Group(Pos("NNP"), "entity") target = Group(Pos("NN") | Pos("NNS"), "target") regex = LISTOPEN + entity + target def semantics(self, match): entity = HasKeyword(match.entity.tokens) target_type = HasKeyword(match.target.lemmas) target = HasType(target_type) + IsRelatedTo(entity) label = LabelOf(target) return label, "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 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 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 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 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 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"
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 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('show'))) + (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 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 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 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 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"
# This file is part of quepy and is distributed under the Modified BSD License. # You should have received a copy of license in the LICENSE file. # # Authors: Rafael Carrascosa <*****@*****.**> # Gonzalo Garcia Berrotaran <*****@*****.**> """ Writers related regex. """ from refo import Plus, Question from quepy.semantics import HasKeyword from quepy.regex import Lemma, Lemmas, Pos, RegexTemplate, Particle from semantics import IsBook, HasAuthor, AuthorOf, IsPerson, NameOf nouns = Plus( Pos("DT") | Pos("IN") | Pos("NN") | Pos("NNS") | Pos("NNP") | Pos("NNPS")) class Book(Particle): regex = nouns def semantics(self, match): name = match.words.tokens return IsBook() + HasKeyword(name) class Author(Particle): regex = nouns def semantics(self, match): name = match.words.tokens
#!/usr/bin/env python # coding: utf-8 """ Tv Shows related regex. """ from refo import Plus, Question from quepy.semantics import HasKeyword from quepy.regex import Lemma, Lemmas, Pos, RegexTemplate, Particle from semantics import IsTvShow, ReleaseDateOf, IsPerson, StarsIn, LabelOf, \ HasShowName, NumberOfEpisodesIn, HasActor, ShowNameOf, \ CreatorOf nouns = Plus(Pos("NN") | Pos("NNS") | Pos("NNP") | Pos("NNPS")) class TvShow(Particle): regex = nouns def semantics(self, match): name = match.words.tokens return IsTvShow() + HasShowName(name) class Actor(Particle): regex = nouns def semantics(self, match): name = match.words.tokens return IsPerson() + HasKeyword(name)
class TvShow(Particle): regex = Plus(Question(Pos("DT")) + nouns) def semantics(self, match): name = match.words.tokens return IsTvShow() + HasShowName(name)
class Thing(Particle): regex = Question(Pos("JJ")) + (Pos("NN") | Pos("NNP") | Pos("NNS")) |\ Pos("VBN") def semantics(self, match): return HasKeyword(match.words.tokens)