class TweetController:
"""docstring for Controller"""
def __init__(self):
self.settings = Settings()
# self.auth = OAuthHandler(Listener.api_data["consumer_key"], Listener.api_data["consumer_secret"])
# self.auth.set_access_token(Listener.api_data["access_token"], Listener.api_data["access_token_secret"])
self.api = tweepy.API(self.settings.auth, parser=tweepy.parsers.JSONParser())
self.db = DataBase()
# self.tweet_gui = tweet_gui
self.default_keyword = ['Obama', 'hillary ', 'Trump']
self.db.create_table_if_not_exist()
def start_stream(self):
self.tweet_listener = Listener()
self.stream = Stream(auth=self.settings.auth, listener=self.tweet_listener)
self.stream.filter(track=self.default_keyword, async=True)
def stop_stream(self):
self.stream.disconnect()
def set_keyword(self, default_keyword):
self.default_keyword = default_keyword
print(default_keyword)
def __init__(self):
self.db = DataBase()
# self.panel()
self.canvas_width = 400
self.canvas_height = 0
self.root = Tk()
self.create_window(self.root)
def __init__(self, save_location="data/tweets.json"):
super().__init__()
self.save_location = save_location
self.count = 0
self.analyser = MoodAnalyser()
self.db = DataBase()
self.max_tweets = 10000
print("Listener created")
def __init__(self):
self.settings = Settings()
# self.auth = OAuthHandler(Listener.api_data["consumer_key"], Listener.api_data["consumer_secret"])
# self.auth.set_access_token(Listener.api_data["access_token"], Listener.api_data["access_token_secret"])
self.api = tweepy.API(self.settings.auth, parser=tweepy.parsers.JSONParser())
self.db = DataBase()
# self.tweet_gui = tweet_gui
self.default_keyword = ['Obama', 'hillary ', 'Trump']
self.db.create_table_if_not_exist()
def __init__(self):
self.db = DataBase()
class MoodAnalyser:
def __init__(self):
self.db = DataBase()
def start_up(self):
"""
A function to startup the mood analyser, fetching all the tweets and passing
each tweet to the analyser
:return:
"""
count = 0
tweets = self.db.fetch_all_tweets()
for tweet in tweets:
count += 1
self.analyse(tweet, count)
# print(tweet)
def analyse(self, tweet, count):
"""
Analyser each word using the moodvalue file words
:param tweet:
:param count:
:return:
"""
tweet = "".join(tweet)
processed_text = self.process_text(tweet)
# calculate mood
score = 0
for word in processed_text:
if word in mood_values.positive_words:
score += 0.6
if word in mood_values.negative_words:
score -= 0.5
self.scoring(score, count)
def scoring(self,tweet_score, tweet_number):
"""
Setting the score of each tweet
:param tweet_score:
:param tweet_number:
:return:
"""
if tweet_score <= -1:
# tweet is negative
self.db.set_mood(tweet_number, '-1')
elif tweet_score >= 0.5:
# tweet is positive
self.db.set_mood(tweet_number, "+1")
else:
# tweet is neutral
self.db.set_mood(tweet_number, "0.5")
def process_text(self, text):
"""
A function to process the text of the tweet stripping all the links and white spaces.
:param text:
:return:
"""
text = text.lower()
# Remove links
text = re.sub('((www\.[^\s]+)|(https?://[^\s]+)|(http://[^\s]+))', 'URL', text)
# Remove mentions
text = re.sub('@[^\s]+', 'MENTION', text)
# Remove white spaces
text = re.sub('[\s]+', ' ', text)
# Remove hashtag from words
text = re.sub(r'#([^\s]+)', r'\1', text)
# trim
text = text.strip('\'"')
# Split text to array
text = text.split()
return text
class Main(object):
def __init__(self):
self.db = DataBase()
# self.panel()
self.canvas_width = 400
self.canvas_height = 0
self.root = Tk()
self.create_window(self.root)
def create_window(self, master):
self.add_canvas(master)
self.start_page(master)
master.mainloop()
def add_canvas(self, master):
self.canvas = Canvas(self.root, width=self.canvas_width, height=self.canvas_height, background='white')
self.canvas.grid(column=0, row=0, sticky=(N, W, E, S))
self.canvas.pack()
def start_page(self, master):
label = Label(master, text="ISCP - Sevak Mardirosian", font=("Helvetica", 16))
label.pack()
Button1 = tk.Button(master, text="Bar Chart!", command=lambda: self.bar_chart(), bg="gray",
fg="white", font="Helvetica")
Button1.pack()
Button2 = tk.Button(master, text="Time Chart", command=lambda: self.time_chart(), bg="gray",
fg="white", font="Helvetica")
Button2.pack()
Button3 = tk.Button(master, text="Pie Chart!", command=lambda: self.pie_chart(), bg="gray",
fg="white", font="Helvetica")
Button3.pack()
Button4 = tk.Button(master, text="Heat Map!", command=lambda: self.heat_map(), bg="gray",
fg="white", font="Helvetica")
Button4.pack()
def bar_chart(self):
plt.xlabel('Sentiment')
plt.ylabel('Number')
# X is negatief, neutraal, positief
# Y is het Number
data = ['Negatief', 'Neutral', 'Positive']
x = np.arange(len(data))
y = self.db.get_mood()
width = 0.8
plt.bar(x, y, width, color="darkblue")
plt.xticks(x + 0.4, data)
plt.tight_layout()
plt.show()
def time_chart(self):
plt.figure(figsize=(30, 10))
date_list = []
score_List = []
data = self.db.get_time_chart()
for rij in data:
date_list.append(datetime.datetime.fromtimestamp(rij[0] / 500.0))
score_List.append(rij[1])
plt.plot(date_list, score_List)
plt.show()
def pie_chart(self):
dataLabels = "Negatief", "Neutraal", "Positief"
dataSize = self.db.get_mood()
colors = "firebrick", "yellow", "lightskyblue"
explode = (0, 0, 0)
plt.pie(dataSize, explode=explode, labels=dataLabels, colors=colors, autopct='%1.1f%%', shadow=True,
startangle=90)
plt.axis('equal')
plt.show()
def heat_map(self):
# label = tk.Label(self, text="Heat Map", font=LARGE_FONT)
# label.pack(pady=10, padx=10)
title = "ROC's AUC"
xlabel = "Timeshift"
ylabel = "Scales"
N = self.db.fetch_all_scores()
data = np.random.rand(8, 12)
f = plt.figure()
plt.title(title)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
c = plt.pcolor(data, edgecolors='k', linewidths=4, cmap='RdBu', vmin=0.0, vmax=1.0)
plt.colorbar(c)
plt.show()
class Listener(StreamListener):
# get a dictionary with keys for the twitter api
# fr = open('config/config.json')
# api_data = json.loads(fr.read())
# fr.close()
def __init__(self, save_location="data/tweets.json"):
super().__init__()
self.save_location = save_location
self.count = 0
self.analyser = MoodAnalyser()
self.db = DataBase()
self.max_tweets = 10000
print("Listener created")
def on_data(self, data):
print("tweets receiving..")
tweets = json.loads(data)
try:
if self.db.fetch_number_of_tweets() != self.max_tweets:
timestamp = tweets["timestamp_ms"]
tweet = tweets["text"]
userData = tweets["user"]
user = userData["screen_name"]
if tweet.startswith("RT @") or tweet.startswith("@"):
return True
if '"' in tweet:
tweet.replace('"', "")
if '"' in user:
user.replace('"', "")
self.db.insert_tweet(tweet, user, timestamp)
else:
# self.on_disconnect()
self.analyser.start_up()
return False
except KeyError as e:
print(e)
def save_tweets(self):
print("Saving tweets to tweets.json")
f = open(os.path.dirname(__file__) + self.save_location, "w")
f.write(jsonstruct.encode(self.tweets))
f.close()
# def create_tweet(self, status):
# return print(Tweet(status.text.encode("utf8"), str(status.created_at), status.user.screen_name))
def on_error(self, status_code):
sys.stderr.write("Error:" + str(status_code) + "\n")
return False
def on_limit(self, track):
sys.stderr.write(track + "\n")
return
def on_timeout(self):
sys.stderr.write("Timeout, sleeping for 60 seconds ...\n")
time.sleep(60)
return
def on_disconnect(self):
print("Disconnected")
Stream.disconnect()
return
