def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
reader = csv.reader(open('data/sentiment.txt', 'rb'))
self.sentiment = dict(reader)
#stem everything in the dictionary and put it in a new dictionary called stemmedSentiment
for key in self.sentiment:
newKey = key.lower()
newKey = self.p.stem(newKey, 0, len(newKey)-1)
self.stemmedSentiment[newKey] = self.sentiment[key]
del self.stemmedSentiment['actual']
for i, happyWord in enumerate(self.happyWords):
happyWord = self.p.stem(happyWord, 0, len(happyWord)-1)
self.happyWords[i] = happyWord
for j, angryWord in enumerate(self.angryWords):
angryWord = self.p.stem(angryWord, 0, len(angryWord)-1)
self.angryWords[j] = angryWord
for title in self.titles:
genres = []
for genre in title[1].split('|'):
genres.append(genre)
movie_data = [genres, randint(-1, 1)]
self.movieDB[title[0]] = movie_data
def read_data(self):
self.titles, self.ratings = ratings()
reader = csv.reader(open('data/sentiment.txt', 'rb'))
self.sentiment = dict(reader)
#stem everything in the dictionary and put it in a new dictionary called stemmedSentiment
for key in self.sentiment:
newKey = key.lower()
newKey = self.p.stem(newKey, 0, len(newKey) - 1)
self.stemmedSentiment[newKey] = self.sentiment[key]
del self.stemmedSentiment['actual']
for i, happyWord in enumerate(self.happyWords):
happyWord = self.p.stem(happyWord, 0, len(happyWord) - 1)
self.happyWords[i] = happyWord
for j, angryWord in enumerate(self.angryWords):
angryWord = self.p.stem(angryWord, 0, len(angryWord) - 1)
self.angryWords[j] = angryWord
for title in self.titles:
genres = []
for genre in title[1].split('|'):
genres.append(genre)
movie_data = [genres, randint(-1, 1)]
self.movieDB[title[0]] = movie_data
def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
self.titleSet = set(
item[0]
for item in self.titles) #don't want to deal with binary search
self.titleDict = {}
pat = re.compile('(\([0-9\-]*\))')
for title in self.titles:
for m in pat.finditer(title[0]):
newTitle = title[0][:m.start() - 1]
date = m.group()
date = date[1:-1] #comment this out if you want parentheses
if newTitle in self.titleDict:
self.titleDict[newTitle].append(date)
else:
self.titleDict[newTitle] = [date]
reader = csv.reader(open('data/sentiment.txt', 'rb'))
tempSentiment = dict(reader)
self.sentiment = {}
for key, value in tempSentiment.iteritems():
self.sentiment[self.p.stem(key)] = value
def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
self.sentiment = collections.defaultdict(lambda: 0)
reader = csv.reader(file('deps/sentiment.txt'),
delimiter=',',
quoting=csv.QUOTE_MINIMAL)
for line in reader:
word, posNeg = line[0], line[1]
word = self.stemmer.stem(word)
self.sentiment[word] = posNeg
# CM6 - RESPOND TO EMOTION
self.emotion = collections.defaultdict(lambda: 0)
emotionReader = csv.reader(file('deps/emotions.txt'),
delimiter=',',
quoting=csv.QUOTE_MINIMAL)
for line in emotionReader:
currEmotion = line[0]
line = map(int, line[1:])
self.emotion[currEmotion] = line
self.binarize()
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'Lit!'
self.creative = creative
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.sentiment = {}
self.porter_stemmer = PorterStemmer()
sentimentCopy = movielens.sentiment()
for k, v in sentimentCopy.items():
key = self.porter_stemmer.stem(k)
self.sentiment[key] = v
self.user_ratings = []
#############################################################################
# TODO: Binarize the movie ratings matrix. #
#############################################################################
ratings = self.binarize(ratings)
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = ratings
def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
reader = csv.reader(open('sentiment.txt', 'rb'))
self.sentiment = dict(reader)
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'moviebot'
self.creative = creative
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.sentiment = movielens.sentiment()
self.new_sentiment = {}
self.p = PorterStemmer()
# create a new sentiment dict with stemmed keys
for key in self.sentiment:
new_key = self.p.stem(key)
self.new_sentiment[new_key] = self.sentiment[key]
self.bin_ratings = self.binarize(ratings)
# a tuple with the sentiment of the movie being discussed
self.current_sentiment = None
# the movie title entered by the user
self.current_title = None
# a list of current movie candidates
self.current_idxs = []
self.prev_movie = None
self.prev_sentiment = None
# a dict where dict[i] = j is the user's sentiment j for movie index i
# for movies that the user has described and the chatbot has processed
self.user_movies = {}
# a set of movie indexes that the user has already described
self.user_movie_set = set()
self.prefix_match_found = False
self.disambig = False
# if chatbot is in recommend mode, only respond to yes or no
self.recommend_mode = False
# a list of recommendations for the user
self.recommendations = []
self.recommend_idx = 0
# preprocess movie list by extracting possible titles and year
self.movies = []
for entry in self.titles:
self.movies.append(extract_titles_and_year(entry[0]))
#############################################################################
# TODO: Binarize the movie ratings matrix. #
#############################################################################
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = ratings
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'Marvin the Marvelous Moviebot'
self.creative = creative
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.titles = lib.standardize_titles(self.titles)
self.sentiment = movielens.sentiment()
self.sentiment = lib.stem_map(self.sentiment)
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = self.binarize(ratings)
# Vector that keeps track of user movie preference
self.user_ratings = np.zeros(len(self.titles))
# Flag that user can update by talking to the chatbot. Set to false when the user asks for a recommendation
# self.add_review = True
# Becomes true once the user's made 5 recommendations.
self.can_recommend = False
# Flag for if quoteless movie title extraction was performed
self.quoteless_title_extraction = False
# Used when Marvin asks if the user wants to accept the spell correction or not
# Variables for remembering info about the movie that's being spell corrected.
self.spell_correction_answer = False
self.spell_correction_prompt = ''
self.spell_correction_movie_index = 0
self.spell_correction_movie_title = ''
self.spell_correction_review = ''
# Used when Marvin cannot determine if a review is pos or neg and asks for more information
# Variables for remembering info about the movie that's going to have its preference updated
self.preference_update_answer = False
self.preference_update_movie_index = 0
self.preference_update_movie_title = 0
# Used when Marvin finds multiple movies that match the description and needs to disambiguate
# Variables for remembering info about the movies that need clarification
self.clarify_answer = False
self.clarify_movie_indicies = []
self.clarify_review = ''
# Used to keep track of recommendations
self.rec_answer = False
self.recommendations = []
self.rec_index = 0
# Used to keep track of the sentiment classification of the last review
self.last_senti = 0
def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
self.make_alternate_titles_dict()
#print(self.alternate_titles_dict)
reader = csv.reader(open('data/sentiment.txt', 'rb'))
self.sentiment = dict(reader)
self.stem_words()
self.non_binarized_matrix = np.copy(self.ratings)
self.binarize()
self.make_movie_to_index_dict()
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'moviebot'
self.SPELL_CHECK_FLAG = False
self.DISAMBIGUATE_FLAG = False
self.creative = creative
self.candidates = None
self.sentiment_last_line = None
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.sentiment = movielens.sentiment()
self.english_titles_set = self.generate_titles()
# Construct a stemmed sentiment lexicon
self.stemmedsentiment = {}
for word in self.sentiment:
self.stemmedsentiment[PorterStemmer().stem(
word)] = self.sentiment[word]
#############################################################################
# TODO: Binarize the movie ratings matrix. #
#############################################################################
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = self.binarize(ratings)
self.user_ratings = np.zeros(len(self.ratings))
self.rated_indices = []
self.movies_processed = set([])
self.already_recommended = set([])
self.recommendations = collections.deque([])
self.ASKED_FOR_REC = False
# Lists used to generate varied responses
self.affirmation_list = [
'Ok', 'Got it', 'Sounds good', 'Great', 'Alright'
]
self.punctuation_list = ['.', '!']
self.more_movies_phrases = [
'Let\'s talk about more movies you\'ve watched',
'Tell me more about some movies you have seen',
'I would love to hear more about some movies you have watched',
'It\'s time to get back to talking about movies you\'ve watched'
]
self.optMovie = ["movie ", ""]
self.recSynonymns = ["recommendation", "suggestion", "option"]
def read_data(self):
#PRE-PROCESS w/ Porter Stemmer
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
reader = csv.reader(open('data/sentiment.txt', 'rb'))
temp = dict(reader)
#QUESTION: SHOULD WE STEM?
for key in temp.keys():
new_key = self.stemmer.stem(key)
self.sentiment[new_key] = temp[key]
def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
reader = csv.reader(open('data/sentiment.txt', 'rb'))
self.sentiment = dict(reader)
self.titlesOnly = []
for entry in self.titles:
titleOnly = entry[0].split(' (')[0]
self.titlesOnly.append(titleOnly.lower())
self.sentiment.update(
{self.p.stem(k): v
for k, v in self.sentiment.items()})
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'moviebot'
self.creative = creative
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.sentiment = movielens.sentiment()
#############################################################################
# TODO: Binarize the movie ratings matrix. #
#############################################################################
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = ratings
def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
reader = csv.reader(open('data/sentiment.txt', 'rb'))
self.sentiment = dict(reader)
for (word, value) in self.sentiment.items():
self.sentiment[self.stemmer.stem(word)] = value
self.titleIndex = {}
for i in range(len(self.titles)):
rawTitle = re.sub(r'(.*) \([0-9]*\)', r'\1',
self.titles[i][0]).lower()
for m in re.finditer(r'\(([^()]*)\)', rawTitle):
altTitle = self.remove_articles(m.group(1))
self.titleIndex[altTitle] = i
primaryTitle = self.remove_articles(
re.sub(r'\([^()]*\)', '', rawTitle).rstrip())
self.titleIndex[primaryTitle] = i
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'Lil_Tae'
self.creative = creative
self.userMovieRatings = np.zeros((1, 1))
self.userMovieMap = {}
self.MOVIELIMIT = 3
self.SENTINAL = 'XY-1-2-XY'
self.ArbritraryMessages = [
"Hmmm... I couldn't understand what movie you are talking about? Can you please ",
"", ""
]
# Beginning booleans and ints to track progress throughout the code:
self.step_count = 0
self.helper_extract_titles_begun = False
self.helper_extract_titles_finish = False
self.helper_find_movies_by_title_begun = False
self.helper_extract_sentiment_begun = False
self.helper_extract_sentiment_second_attempt = False
self.helper_recommend_begun = False
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.sentiment = movielens.sentiment()
#############################################################################
# TODO: Binarize the movie ratings matrix. #
#############################################################################
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = ratings
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'VAHN'
self.creative = creative
self.titles, ratings = movielens.ratings()
self.sentiment = movielens.sentiment()
self.sentiment_stemmed = {}
for word in self.sentiment:
self.sentiment_stemmed[stemmer.stem(word)] = self.sentiment[word]
self.debuggy = []
#to help print states
self.recommendations = 0
self.clarify = False
self.candidates = []
self.originalLine = ""
self.moreInfo = False
self.movieTitle = ""
self.multipleMovies = False
self.processTextConf = False
self.user_ratings = [0] * len(self.titles)
self.rec = False
self.title_id = 0
self.multimovieInput = False
self.remainingMulti = []
self.multiSent = []
#to save sentiment if you go thru disambiguate
self.sent = 0
self.sentBool = False
#############################################################################
# TODO: Binarize the movie ratings matrix. #
#############################################################################
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = self.binarize(ratings)
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'MotherBot'
self.creative = creative
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.sentiment = movielens.sentiment()
#############################################################################
# TODO: Binarize the movie ratings matrix. #
#############################################################################
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = self.binarize(ratings)
assert (len(self.titles) == len(self.ratings))
self.user_ratings = np.zeros((len(self.titles), ))
self.n_data_points = 0
self.casual_titles = self.make_casual_titles() if self.creative else []
def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
# Process movie titles from 'Lion King, The (1994)' -> 'The Lion King (1994)'
self.titles = [(self.processMovieTitle(title), genre)
for (title, genre) in self.titles]
self.titlesWithoutDate = [
self.removeYear(t).lower() for t, _ in self.titles
]
self.titlesWithoutArticle = [
self.removeArticle(t).lower() for t in self.titlesWithoutDate
]
self.ratings = np.array(self.ratings)
reader = csv.reader(open('data/sentiment.txt', 'rb'))
self.sentiment = dict(reader)
self.sentiment = {
self.p.stem(k): v
for k, v in self.sentiment.iteritems()
}
self.pearsonize()
self.binarize()
def read_data(self):
"""Reads the ratings matrix from file"""
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, self.ratings = ratings()
self.normalize()
#This will be a dictionary containing all information to a parsed title,
#a list mapping pseudonyms to titles, and the initial user ratings vec
self.titles_dict = {}
self.pseudonyms = {}
self.user_ratings = []
# For storing, I thought maybe we could just use all lower case. That way
# we can generalize to the creative case right away.
# The only problem we have here is we are assuming unique names...
# Think I am going to change this a bit...
for i in range(len(self.titles)):
p_title, pseudos, year, f_title = title_parse(self.titles[i][0])
key = p_title.lower()
if year != "":
key += ' (' + year + ')'
self.titles_dict[key] = {
PARSED: p_title.lower(), # Parsed version of title
PSEUDOS: pseudos, # List of pseudonyms
YEAR: year, # Year the movie was made
GENRES: self.titles[i][1], # Genres of movie
INDEX: i, # Row index into the rating matrix
CAP: f_title # Capitalized version of movie
}
for p in pseudos:
self.pseudonyms[p.lower()] = key
# !!!!!!!EDITED FOR PYTHON3!!!!!!!!
reader = csv.reader(open('data/sentiment.txt', 'rt', encoding="utf-8"))
self.sentiment = dict(reader)
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'MovieMaster'
self.creative = creative
self.opposite = {
'dont', 'didnt', 'wont', 'wasnt', 'werent', 'hasnt', 'cant',
'shouldnt', 'never', 'not', 'hardly', 'seldom', 'rarely', 'cannot'
}
self.strong_words = {
'love', 'hate', 'best', 'worst', 'amazing', 'wonderful',
'majestic', 'favorite', 'really', 'very', 'awful', 'terrible',
'cringe', 'awesome'
}
self.stemmer = PorterStemmer()
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.sentiment = movielens.sentiment()
self.current_ratings = np.zeros(len(self.titles))
self.k = 5
self.ratings_given = 0
self.top_movies = []
self.pos_response = {
"yeah", "yea", "ya", "y", "yes", "ye", "yeet", "yess", "yesss",
"yessir", "yes sir", "yes ma'am", "yes mam", "yeeters", "sure",
"ok", "okay", "yuh", "yup", "fine", "twist my arm"
}
self.neg_response = {
"no", "nah", "na", "n", "nope", "no sir", "no ma'am", "no mam",
"negative", "not today", "not", "bye", "cya", "nopers"
}
# creative features
self.have_another_rec = [
"I never thought you'd ask! This movie might be even more perfect for you: \"%s\"",
"\"%s\" would make the perfect Netflix and chill vid. ",
"I think you are really going to love \"%s\" ",
"Based on what you've told me, you should try \"%s\" ",
"Wow, you're clearly planning to Netflix binge, aren't you? I think you'd like \"%s\"",
"How about \"%s\" ",
"You should really be studying for midterms, but \"%s\" would definitely put you"
"in the right mood for them. "
]
self.want_another_rec = [
"Do you want another recommendation? ", "Need another one? ",
"Want another one to procrastinate more? ",
"Do you want more movie recs? "
]
self.emotion_lines = {
"sad": [
"Aww I hope you feel better soon. ",
"Oy, We all have those days. "
"Merp maybe a great movie could cheer you up? "
],
"angry": [
"I am so so sorry for whatever I did to upset you. ",
"Wow I apologize. Please accept my apology! ",
"I must have done something pretty awful to upset you so. Let's see if I can make it up to you. ",
"Sounds like you're super mad! My taste in movies can't be thaaat bad. "
],
"scared": [
"Don't be scared! I'm right hear with you! ",
"Sometimes I get scared at night, too. ",
"No reason to be fearful. You're totally safe. ",
"The only thing to fear is fear itself. "
],
"happy": [
"Yay! May your days continue to make you so happy! ",
"Wow that's great!", "That's awesome!"
"Cool!"
]
}
self.ask_for_movie = [
"Why don't you tell me about a movie you've seen recently? ",
"Seen any good movies recently? ",
"What's a movie you have strong feelings about. ",
"There are so many movies out there. Have any thoughts on them? "
]
self.pivot = [
"Let's go back to talking about movies. ",
"Maybe we should talk about what I do best: movies. "
"Let's talk about movies! "
]
self.clarify = [
"I'm sorry, I didn't understand that. ",
"I didn't totally understand what you said."
]
self.switch = [
"Do you want to tell me more about movies, or do you want to hear some recommendations? ",
"Are you ready to hear recommendations, or do you want to teach me more about what you like? "
]
self.dict = {}
self.active_movie = ""
self.conversation_point = "collecting"
self.active_movies_titles = []
self.emotional_count = 0
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = self.binarize(ratings, 2.5)
def __init__(self, creative=False):
# The chatbot's default name is `moviebot`. Give your chatbot a new name.
self.name = 'Lit!'
self.creative = creative
# This matrix has the following shape: num_movies x num_users
# The values stored in each row i and column j is the rating for
# movie i by user j
self.titles, ratings = movielens.ratings()
self.problems_list = []
self.problem = 0
self.confirmation_list = []
self.suggested = []
self.currentMovies = []
#self.extreme_sentiment = movielens.extract_sentiment()
self.sentiment = {}
self.porter_stemmer = PorterStemmer()
sentimentCopy = movielens.sentiment()
for k, v in sentimentCopy.items():
key = self.porter_stemmer.stem(k)
self.sentiment[key] = v
self.user_ratings = []
#############################################################################
# TODO: Binarize the movie ratings matrix. #
#############################################################################
ratings = self.binarize(ratings)
# Binarize the movie ratings before storing the binarized matrix.
self.ratings = ratings
self.drinks = {
"Comedy": "Riesling, for the levity and dry humor.",
"Romance":
"Cabernet Sauvignon from Chateau Montelena, a California favorite.",
"Drama": "Rosé, duh!",
"Documentary": 'Craft Beer, to connect with the local.',
"Crime":
"19 Crimes Cabernet Sauvignon, to fuel your investigation.",
"Children": "Juice Box, to taste the fun!",
"Sci-Fi": "Water, to stay grounded.",
"Action": "a case of your favorite IPA.",
"Adventure":
"to get out there and whip up something in the kitchen yourself!",
"IMAX":
"to get out there and whip up something in the kitchen yourself!",
"Fantasy": "Champagne, for the light and whimsical.",
"Horror": "Bloody Mary, to be in theme.",
"Thriller": "Bloody Mary, to dull the senses.",
"Mystery":
"Merlot, to bring out distinguished depth and character.",
"Animation": "Soda, for a little pep in your step.",
"War": "Whiskey, because we know that's what they'd be drinking."
}
self.snacks = {
"Comedy": "popcorn",
"Romance": "chocolate covered strawberries",
"Drama": "prosciutto with melon",
"Documentary": "vegetables",
"Crime": "blue cheese on crackers",
"Children": "Sour Patch Kids",
"Sci-Fi": "sugar cookies",
"Action": "action food",
"Adventure": "trail mix",
"Fantasy": "Skittles",
"Horror": "a light meal",
"Thriller": "mini hamburgers",
"Mystery": "Junior Mints",
"Animation": "cookies decorated with frosting",
"War": "no food"
}
self.starters = [
"Great!", "Okay,", "Interesting...",
"This is great information to know.", "", "Sounds good!",
"This is really useful information, thanks for sharing it with me!",
"No way! I just watched that movie last weekend."
]
self.reactions = [
"an awesome script", "such beautiful cinematography",
"powerful emotional scenes", "such a striking visual display",
"a beautiful score", "some of the worst extras I have ever seen",
"really great costume design"
]
self.positive_words = [
"enjoyed", "loved", "quite liked", "want to see more movies like",
"appreciated", "adored", "might enjoy a movie similar to", "liked"
]
self.negative_words = [
"disliked", "didn't enjoy", "were not a fan of",
"didn't really vibe with",
"don't want to watch another movie like",
"want to avoid anything similar to"
]
self.check_sentiment = [
"I'm not sure whether or not you enjoyed ",
"I couldn't make out whether you liked ",
"I'm sorry, but I couldn't make out whether you enjoyed ",
"This is such helpful information. I didn't quite catch how you felt about "
]
self.check_sentiment_clarify = [
"Could you tell me a bit more about how you felt watching it?",
"Why don't you tell me about some of your reactions to the movie?",
"I remember really enjoying that movie--can you tell me about a few things you liked or didn't like about this movie?",
"Could you elaborate on your experience watching it?"
]
self.suggestion_lead = [
"I suggest you watch", "I think that you would love",
"I sense that you would really vibe with",
"Okay, I think that you would really enjoy",
"I bet that you would appreciate"
]
