import pandas as pd
import json
from sklearn.ensemble import VotingClassifier
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression, RidgeClassifier
from sklearn.naive_bayes import MultinomialNB
from tweepy import OAuthHandler, Stream, StreamListener
# Please fill your API keys as strings
consumer_key="HERE,"
consumer_secret="HERE,"

access_token="HERE,"
access_token_secret="AND HERE"

We then proceed to create and train our TfidfVectorizer and VotingClassifier with 30,000 features and n-grams in the [1, 3] range:

# Load the data
data = pd.read_csv('sent140_preprocessed.csv')
data = data.dropna()
# Replicate our voting classifier for 30.000 features and 1-3 n-grams
train_size = 10000
tf = TfidfVectorizer(max_features=30000, ngram_range=(1, 3),
                         stop_words='english')
tf.fit(data.text)
transformed = tf.transform(data.text)
x_data = transformed[:train_size].toarray()
y_data = data.polarity[:train_size].values
voting = VotingClassifier([('LR', LogisticRegression()),
                           ('NB', MultinomialNB()),
                           ('Ridge', RidgeClassifier())])
voting.fit(x_data, y_data)

We then proceed with defining our StreamClassifier class, responsible for listening for incoming tweets and classifying them as they arrive. It inherits the StreamListener class from tweepy. By overriding the on_data function, we are able to process tweets as they arrive through the stream. The tweets arrive in JSON format, so we first parse them with json.loads(data), which returns a dictionary, and then extract the text using the "text" key. We can then extract the features using the fitted vectorizer and utilize the features in order to predict its polarity:

# Define the streaming classifier
class StreamClassifier(StreamListener):
    def __init__(self, classifier, vectorizer, api=None):
        super().__init__(api)
        self.clf = classifier
        self.vec = vectorizer
    # What to do when a tweet arrives
    def on_data(self, data):
        # Create a json object
        json_format = json.loads(data)
        # Get the tweet's text
        text = json_format['text']
        features = self.vec.transform([text]).toarray()
        print(text, self.clf.predict(features))
        return True
    # If an error occurs, print the status
    def on_error(self, status):
        print(status)

Finally, we instantiate StreamClassifier, passing as arguments, the trained voting ensemble and TfidfVectorizer and authenticate using the OAuthHandler. In order to start the stream, we instantiate a Stream object with the OAuthHandler and StreamClassifier objects as parameters and define the keywords we want to track with filter(track=['Trump']). In this case, we track tweets that contain the keyword 'Trump' as shown here:

# Create the classifier and authentication handlers
classifier = StreamClassifier(classifier=voting, vectorizer=tf)
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)

# Listen for specific hashtags
stream = Stream(auth, classifier)
stream.filter(track=['Trump'])

That's it! The preceding code now tracks any tweet containing the keyword Trump and predicts its sentiment in real time. The following table depicts some simple tweets that were classified: