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)
