from config import consumer_key, consumer_secret, access_token, access_token_secret
import tweepy

%matplotlib inline
import matplotlib.pyplot as plt
import datetime
import numpy as np
import pandas as pd
import seaborn as sns; sns.set()

# Creating the authentication object
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
# Setting your access token and secret
auth.set_access_token(access_token, access_token_secret)
# Creating the API object while passing in auth information
api = tweepy.API(auth) 

def get_tweets(listOfTweets, user, numOfTweets):
    # Iterate through all tweets of specific user
    for tweet in tweepy.Cursor(api.user_timeline, id=user).items(numOfTweets):
        # Add tweets in this format
        dict_ = {'Screen Name': tweet.user.screen_name,
                'Tweet Created At': pd.to_datetime(tweet.created_at),
                'Tweet Text': tweet.text,
                }
        listOfTweets.append(dict_)   

data = []

get_tweets(data, 'BoredElonMusk', 1000)
get_tweets(data, 'elonmusk', 1000)
data_df = pd.DataFrame(data)

data_df.head()

data_df.tail()

data_df['tweet_cleaned'] = data_df['Tweet Text']

pat1 ='RT @[\w_]+: '
pat2 = r'@[A-Za-z0-9]+'
pat3 = r'https?://[A-Za-z0-9./]+'
pat4 = r'[^a-zA-Z ]+'
combined_pat = r'|'.join((pat1, pat2, pat4))

from bs4 import BeautifulSoup
data_df['tweet_cleaned'] = data_df.tweet_cleaned.str.replace(pat3, '')
data_df['tweet_cleaned'] = [BeautifulSoup(text, 'lxml').get_text() for text in data_df['tweet_cleaned'] ]
data_df['tweet_cleaned'] = data_df.tweet_cleaned.str.replace(combined_pat, '')
data_df.head()

from sklearn.model_selection import train_test_split

X = data_df['tweet_cleaned']
y = data_df['Screen Name']
Xtrain, Xtest, ytrain, ytest = train_test_split(X, y, random_state=1991)

# convert content of string into vector of numbers using TF-IDF
# use pipeline to attach vectorized text data to multinomial bayes classifier
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import make_pipeline

model = make_pipeline(TfidfVectorizer(), MultinomialNB())

# apply model to training data and predict labels for test data
model.fit(Xtrain, ytrain)
ypred = model.predict(Xtest)

# need to see how the classifier orders the classes so I can use them for the confusion matrix
labels = model.classes_
labels.tolist()

from sklearn.metrics import confusion_matrix
from sklearn.utils.multiclass import unique_labels

labels = model.classes_

mat = confusion_matrix(ytest, ypred)
sns.heatmap(mat, square=True, annot=True, cbar=False, cmap='Blues', fmt='g', 
            xticklabels=labels.tolist(), yticklabels=labels.tolist())
plt.xlabel('Predicted value')
plt.ylabel('True value');

# see fraction of predicted labels that match their true value
from sklearn.metrics import accuracy_score
accuracy_score(ytest, ypred)

import sys
!{sys.executable} -m pip install wordcloud

from wordcloud import WordCloud, STOPWORDS, ImageColorGenerator

bored_elon = data_df[data_df['Screen Name'] == 'BoredElonMusk']
elon = data_df[data_df['Screen Name'] == 'elonmusk']

stop_words = ['BoredElonMusk', 'elonmusk', 'youre'] + list(STOPWORDS)
    
# Create and generate a word cloud image:
wordcloud = WordCloud(max_font_size=50, max_words=100, background_color="white", 
                      stopwords=stop_words).generate(' '.join(elon['tweet_cleaned']))

# Display the generated image:
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()

# Create and generate a word cloud image:
wordcloud = WordCloud(max_font_size=50, max_words=100, background_color="white", 
                      stopwords=stop_words).generate(' '.join(bored_elon['tweet_cleaned']))

# Display the generated image:
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis("off")
plt.show()