check = 2 counterimgs += 1 except: pass # if check == 2: # sys.exit() def on_error(self, status_code): print("algo ha pasao ", status_code) #auth shinannigans keys = json.loads(open("credenciales.json").read()) auth = tweepy.OAuthHandler(keys["consumer_key"], keys["consumer_secret"]) auth.set_access_token(keys["access_token"], keys["access_token_secret"]) tapi = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True) # logica prebarrido print( "word based image scrapper, creara una carpeta llamada imgs en donde este programa este alojado" ) print("Dame la palabra sobre la que quieres monitorizar:") targetWord = input() stream = TweetListener() streamingApi = tweepy.Stream(auth=tapi.auth, listener=stream) streamingApi.filter(track=[targetWord], )
def stream_listener(): stream_listener = StreamListener() print("Stream Starting...\n") stream = tweepy.Stream(auth=myAPI.auth, listener=stream_listener) stream.filter(track=["@paul2greasy"])
'ignore'), decoded['coordinates'], decoded['user']['location']) print '' coords = decoded['coordinates'] if coords: self.store_data(coords) return True def store_data(self, coords): coords = coords['coordinates'] firebase_ref.post('/processed_coords', coords) def on_error(self, status): print status if __name__ == "__main__": l = StdOutListener() url = 'https://stream.twitter.com/1.1/statuses/filter.json?delimited=length&track=twitterapi&' auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET) auth.set_access_token(ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET) stream = tweepy.Stream(auth, l) stream.filter(track=[ 'happybirthday', 'happy birthday', 'feliz cumpleanos', 'felizcumpleanos', 'joyeux anniversaire', 'joyeuxanniversaire' ])
import tweepy import Myauth class twitterStream(tweepy.StreamListener): def on_status(self, status): reply_status = "@%s %s" % (status.author.screen_name, "follow back") # api.update_status(status=reply_status, in_reply_to_status_id=status.id) api.create_favorite(status) api.create_friendship(status.author.screen_name) print(status.author.screen_name) def on_error(self, status_code): if status_code == 420: # returning False in on_data disconnects the stream return False api = tweepy.API(Myauth.auth) myStreamListener = twitterStream() myStream = tweepy.Stream(auth=api.auth, listener=myStreamListener) myStream.filter(track=['python'])
# entities provide structured data from Tweets including resolved URLs, media, hashtags and mentions without having to parse the text to extract that information tweet_text = status.text print(status.user.screen_name + ' tweeted you ' + status.text) if 'separation' in tweet_text or 'departure' in tweet_text: api.update_status('@' + username + random.choice(departure.values())) print(username + ' sent ' + tweet_text + ' and we responded with a departure quote') elif 'initiation' in status.text: api.update_status('@' + username + random.choice(initiation.values())) print(username + ' sent ' + tweet_text + ' responded with initiation quote') elif 'return' in status.text: api.update_status('@' + username + random.choice(ret.values())) print(username + ' sent ' + tweet_text + 'responded with return quote') elif 'whats up' in tweet_text: api.update_status('@' + username + ' not much wasuup w u?') myStreamListener = BotStreamer() # Construct the Stream instance stream = tweepy.Stream(auth, myStreamListener) stream.filter(track=[ 'nickiboi_c' ]) #filter the stream for tweets with "nickiboi_c" in them
# subject = 'News Tweets' # # body is a variable that is a formatted version for the tweets that are sent to the email. # # Each tweet will occupy a row that has the username of the person who sent the tweet, the text of the tweet, and the link of the tweet. # body = f"""{(tweets[0].user.name)}: {(tweets[0].text)} (https://twitter.com/i/web/status/{tweets[0].id_str})\n{(tweets[1].user.name)}: {(tweets[1].text)} # (https://twitter.com/i/web/status/{tweets[1].id_str})\n{(tweets[2].user.name)}: {(tweets[2].text)} (https://twitter.com/i/web/status/{tweets[2].id_str})\n{(tweets[3].user.name)}: # {(tweets[3].text)} (https://twitter.com/i/web/status/{tweets[3].id_str})\n{(tweets[4].user.name)}: {(tweets[4].text)} (https://twitter.com/i/web/status/{tweets[4].id_str})""" # message = 'Subject: {}\n\n{}'.format(subject, body) # Message sent for the email. # server.sendmail('*****@*****.**', input('Enter your email to get the news tweets!: \n'), message.encode('ascii', 'ignore')) # The email with the tweets will be sent from my personal email to my school email. # print('Email has been sent!') # playsound('youGotmail.mp3') # plays sound effect when email has been sent. # server.quit() # The SMTP server stops once the email has been sent. streamListener = TwitterStreamListener() # Instance of TwitterStreamListener. stream = tweepy.Stream( auth=api.auth, listener=streamListener ) # Stream of tweets which the streamListener object will record. stream.filter( follow=['428333', '807095', '2467791'], track=['President Trump', 'News'], languages=['en'] ) # This will filter the stream of tweets. I will only get tweet that contain the words 'President Trump' as he popular on the news currently. body2 = f"yo" for tweet in arr_of_tweets: body2 + f"hello" print(body2) # send_mail(arr_of_tweets) # Sends the array of tweets to my email.
writer = csv.writer(f) writer.writerow([ str(uuid1()), self.sanitize_text(status.text), status.author.name, status.created_at ]) time.sleep(1) def sanitize_text(self, text: str) -> str: return re.sub(r'[\n,]', ' ', text) if __name__ == '__main__': log.basicConfig(level=log.INFO) api_key = config('API_KEY') api_secret_key = config('API_KEY_SECRET') access_token = config('ACCESS_TOKEN') access_secret_token = config('ACCESS_TOKEN_SECRET') auth = tweepy.OAuthHandler(api_key, api_secret_key) auth.set_access_token(access_token, access_secret_token) stdout_stream = tweepy.Stream(auth, StdOutStream()) datapipe_csv_stream = tweepy.Stream(auth, DataPipeStream()) # stream-load tweets that match condition print('Starting stream...') datapipe_csv_stream.filter(track=['ps5', '楽天', '買えた'], languages=['ja'])
processed_doc["text"] = x["text"] return processed_doc # Custom listener class class StdOutListener(StreamListener): # Don't touch this """ A listener handles tweets that are received from the stream. This is a basic listener that just pushes tweets to pubsub """ def __init__(self): super(StdOutListener, self).__init__() self._counter = 0 def on_data(self, data): data = json.loads(data) write_to_pubsub(reformat_tweet(data)) self._counter += 1 return True def on_error(self, status): if status == 420: print("rate limit active") return False # Start listening trump_api = StdOutListener() stream_trump = tweepy.Stream(auth, trump_api, tweet_mode='extended') stream_trump.filter(track=trump_hashtags)
def main(keywords): api = create_api() tweets_listener = RetweetListener(api) stream = tweepy.Stream(auth=api.auth, listener=tweets_listener) stream.filter(track=keywords, languages=["en"]) time.sleep(60)
def streamingSearch(cls, auth, instance, query): StreamingApiForSearch = instance start_time = time.time() mystreaming = tweepy.Stream(auth=auth, listener=StreamingApiForSearch) mystreaming.filter(track=query, languages=["en"])
limit = 500 class MyStreamListener(StreamListener): def __init__(self): super(MyStreamListener, self).__init__() self.num_tweets = 0 def on_data(self, data): if self.num_tweets < limit: self.num_tweets += 1 try: with open('tweet_mining.json', 'a') as tweet_file: tweet_file.write(data) return True except BaseException as e: print("Failed on data: %s" % str(e)) return True else: return True def on_error(self, status): print(status) return True twitter_stream = tweepy.Stream(auth, MyStreamListener()) twitter_stream.filter(track=keyword_list)
def start_listener(api, username): l = MyStreamListener() streamer = tweepy.Stream(auth=api.auth, listener=l) streamer.filter(follow=[username], async=True)
def filter_tweets(keyword, api): myStreamListener = MyStreamListener() myStream = tweepy.Stream(auth = api.auth, listener=myStreamListener) myStream.filter(track=[keyword])
def initialize_twitter_stream(self): if self.twitter_stream is None: self.twitter_stream = tweepy.Stream(self.twitter_auth, self.listener, retry_420=3 * 60)
#print out a message to the screen that we have collected a tweet print("Tweet de " + format(name.encode('utf-8'),'>25') + "\tposté le " + str(created_at) + "\ten " + str(lang.upper()) + "\tenregistré") # print(text + "\n") #insert the data into the mongoDB into a collection called twitter_search #if twitter_search doesn't exist, it will be created. datajson['tweet_corrige'] = " " datajson['utilisateurs'] = {} datajson['signalements'] = 0 datajson['evaluations'] = 0 datajson['valide'] = False if datajson['truncated'] == False: datajson['tweet_complet'] = datajson['text'] else: datajson["tweet_complet"] = datajson['extended_tweet']['full_text'] db.twitter_search.insert(datajson) except Exception as e: print(e) auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET) auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET) #Set up the listener. The 'wait_on_rate_limit=True' is needed to help with Twitter API rate limiting. listener = StreamListener(api=tweepy.API(wait_on_rate_limit=True)) streamer = tweepy.Stream(auth=auth, listener=listener) print("Tracking" + str(dico)) streamer.filter(track=dico)
#append ai-answer to the memory memory.append(replyText.replace('notgewure', '')) print(memory) # check if repsonse is over 140 char if len(replyText) > 140: replyText = replyText[0:138] + '..' print('Tweet ID: ' + tweetId) print('From: ' + screenName) print('Tweet Text: ' + tweet.get('text')) print('Reply Text: ' + replyText) # If rate limited, the status posts should be queued up and sent on an interval TODO tapi.update_status(replyText, tweetId) except: print(traceback.format_exc()) print("an exception occured") def on_error(self, status): print("on_error") print(status) if __name__ == '__main__': streamListener = ReplyToTweet() twitterStream = tweepy.Stream(auth, listener=streamListener) twitterStream.filter(track=['@notgewure'])
def streamBasic(): print('StartBasic') myStreamListener = MyStreamListener() myStream = tweepy.Stream(auth=api.auth, listener=myStreamListener) myStream.sample(languages=['en'], async=True)
def tw_stream(api): myStreamListener = MyStreamListener() myStream = tweepy.Stream(auth=api.auth, listener=myStreamListener()) myStream.filter(track=qw, async=True)
def on_error(self, status): print("Error detected") print(status) # Authenticate to Twitter auth = tweepy.OAuthHandler("CQTGkAGL1TSNX5MVShJvXjk7H", "nvJopSrix84GSCHShhr4fd0lf4HvZuDvMy0E0b3TQPIlO6LF1L") auth.set_access_token("794777197470830593-0fQdci4AGivrgv2IQy5CAKW7e1VDf12", "kkUxcZC2YGQHuDZpHcvXOiniDW4mXwaTdvQtSjXi7nuax") # Create API object api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True) tweets_listener = MyStreamListener(api) stream = tweepy.Stream(api.auth, tweets_listener) # print("start stream") # # (stream.filter(track=["#emoj_flowers"], languages=["en","ar" ])) # while True: print("start stream") try: #stream.filter(track=keyword_list, stall_warnings=True) stream = tweepy.Stream(api.auth, tweets_listener) stream.filter(track=["#emoj_flowers"], languages=["en", "ar"],stall_warnings=True) except IncompleteRead as e: # Oh well, sleep sometime & reconnect and keep trying again
id_str = data['id_str'] except KeyError as e: logging.error("Error on_data %s" % str(e)) # Determine the sentiment of the tweet vs = analyzer.polarity_scores(tweet) sentiment = vs['compound'] if not tweet.startswith('RT'): message = json.dumps( { "time_ms": time_ms, "id_str": id_str, "tweet": tweet, "sentiment": sentiment }, sort_keys=True) logging.debug(message) producer.send(topic, message.encode("utf-8")) return True except BaseException as e: logging.error("Error on_data %s" % str(e)) return true myStreamListener = MyStreamListener() myStream = tw.Stream(auth=api.auth, listener=myStreamListener, tweet_mode='extended') myStream.filter(track=[topic], is_async=True)
coords = json.dumps(coords) table = db["tweets"] try: table.insert(dict( user_description=description, user_location=loc, coordinates=coords, text=text, geo=geo, user_name=name, user_created=user_created, user_followers=followers, id_str=id_str, created=created, retweet_count=retweets, polarity=sentiment.polarity, subjectivity=sentiment.subjectivity, )) except ProgrammingError as err: print(err) def on_error(self, status_code): if status_code == 420: return False twitterstream = tp.Stream(auth, listener()) twitterstream.filter(track=['Trump'])
'profile_image_url': status.user.profile_image_url, 'receiver_at': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') } storage.push(tweet_item) print(f"Pushed to Redis: {tweet_item}") def on_error(self, status_code): # Shut down the stream if we get rate limit error if status_code == 420: print("Rate Limit error") return False # Get API Auth tokens config_path = 'config/api.json' with open(config_path) as config_file: twitter_api = json.loads(config_file.read()) consumer_key = twitter_api["consumer_key"] consumer_secret = twitter_api["consumer_secret"] access_token = twitter_api["access_token"] access_token_secret = twitter_api["access_token_secret"] auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) api = tweepy.API(auth) stream = tweepy.Stream(auth=api.auth, listener=StreamListener()) stream.filter(track=TRACKED_BRANDS_LIST)
def collect_by_streaming(): connexion = tcs.twitter_setup() listener = StdOutListener() stream=tweepy.Stream(auth = connexion.auth, listener=listener) stream.filter(track=[nom_candidate])
consumer_secret = '' access_token = '' access_secret = '' auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_secret) api = tweepy.API(auth) file = codecs.open("an_hotel.txt", "w", "utf-8") #Classes class MyStreamListener(tweepy.StreamListener): """ StreamListener to find 'an hotel' and 'an hospital' """ def on_status(self, status): print(status.text.encode('utf-8')) def on_data(self, data): json_data = json.loads(data) file.write(str(json_data)) def on_error(self, status_code): if status_code == 420: #returning False in on_data disconnects the stream return False myStream = tweepy.Stream(auth, MyStreamListener()) myStream.filter(track=["an hotel", "an hospital"], async=True)
TweetListener.add_log( self, consts.LOG_GAME_STOPPED_FAIL + status.user.screen_name) api.update_status( "@" + status.user.screen_name + "\n" + consts.TWEET_GAME_STOPPED_FAIL, status.id) #Searches for a command inside a tweet #If a command is found executes it and returns ok def search_command(self, status): tab = status.text.lower().split() for ta in tab: if ta == consts.COMMAND_START: TweetListener.create_game(self, status) return consts.RETURN_NO_ERROR if ta == consts.COMMAND_QUIT: TweetListener.quit_game(self, status) return consts.RETURN_NO_ERROR #If we receive an error what do we do def on_error(self, status): if status == 420: print "Slowing down..." return False print(status) #launching the bot tmp_player = pendu.player() bot = TweetListener() bot = tweepy.Stream(auth=api.auth, listener=bot) bot.filter(track=['YOURTRACK'])
def get_streaming_tweets(search_word): global myStream print 'the search word is : ' + search_word myStream = tweepy.Stream(auth=api.auth, listener=MyStreamListener()) print myStream myStream.filter(track=[search_word])
clear_output(wait=True) status_array.append(status._json) if self.tweet_number >= self.max_tweets: print('PROCESSING COMPLETE : ' + str(self.max_tweets) + ' tweets processed.') return False #sys.exit('PROCESSING COMPLETE : '+str(self.max_tweets)+' tweets processed.') def on_error(self, status_code): if status_code == 420: return False stream_listener = StreamListener() stream = tweepy.Stream(auth=api.auth, listener=stream_listener) #print('Pulling down data.....') stream.filter(track=[TOPIC], languages=["en"]) elif scantype == 2: # HISTORICAL DATA SWITCHED OFF (IF YOU SWITCH ON, THEN SWITCH STREAM OFF ABOVE) status_array = [] LOOP_COUNT = 0 # ------ENTER YOUR SERACH TERM HER E-------- tweets = tweepy.Cursor(api.search, q=TOPIC, lang='en', count=int(max_count))
def collect_data(tweetsPath, consumer_key, consumer_secret, access_token, access_token_secret, tweets_count_to_collect, terms=['#earthquake', '#tsunami', 'earthquake', 'tsunami']): new_tweets = [] rate_error = False # consumer_key = "JflKYuYqaJvGNkPaZnImasKyS" # consumer_secret = "4NnZJjqyuQHolgoJRrBHdmEjE68ZI2Hl5aJmFFtQEh7IsYaaH9" # access_token = "159404488-0kY7styL2iWoF8f7FWk1Sk2Q2yAluNzOQrZCL4ID" # access_token_secret = "hz1CmckrUmEnB1Jx0rBhJun6P8F5C23mJpiCi3uYj5PCh" auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) api = tweepy.API(auth) storePath = tweetsPath + "/" # terms = ['cyberattack', 'cybersecurity', 'cyberwar', 'DDOS', 'cyberhack', 'cyberespionage', 'cyberrisk'] # terms = ['@INCIndiaLive', '@narendramodi', '#RafaleDeal', '#RahulGandhi', '#NamoAgain', '#NaMoAgain', '#RafaleScam', '#MeraParivarBhajapaParivar', '#Modi4NewIndia', '#PriyankaGandhi', '#PhirEkBaarModiSarkar', '#2019Election', '#MeraParivarBhajpaParivar', 'indian election', 'election in india', 'india election', '@RahulGandhi','@INCIndia'] GEOBOX_WORLD = [-180, -90, 180, 90] # data_count = 0 # tweets_count_to_collect = 10 class StdOutListener(tweepy.StreamListener): def __init__(self, api=None): super(StdOutListener, self).__init__() self.num_tweets = 0 self.start = datetime.utcnow() self.write = codecs.open( storePath + 'tweets_' + str(self.start.month) + '_' + str(self.start.day) + ".json", 'a', 'utf-8') time_now = datetime.now() self.write.write('time:{}\n'.format(str(time_now))) def on_data(self, data): # global write # global start # data_count += 1 try: # print('data_count: ', data_count) self.write.write(str(data)) except Exception as e: print(e) print(str(data)) end = datetime.utcnow() # global start if (end.day != self.start.day): self.start = end write.close() write = codecs.open( storePath + 'tweets_' + str(self.start.month) + '_' + str(self.start.day) + ".json", 'a', 'utf-8') self.num_tweets += 1 if self.num_tweets < tweets_count_to_collect: # print(self.num_tweets) # collection.insert(record) new_tweets.append(str(data)) return True else: return False def on_limit(self, status): print("Rate Limit Exceeded, Sleep for 1 Mins") time.sleep(60) self.num_tweets = self.num_tweets * 2 # get more data in a batch rate_error = True return True def on_error(self, status): if (status == 420): rate_error = True self.num_tweets = self.num_tweets * 2 print( 'Because of error, updating the number of tweets to download: ', self.num_tweets) print('error status', status) # if __name__ == '__main__': l = StdOutListener() auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) stream = tweepy.Stream(auth, l) # while(True): try: stream.filter(track=terms, encoding='utf-8') #locations=GEOBOX_WORLD, except KeyboardInterrupt: print('keyboard interruptions detected') stream.disconnect() # break except Exception as e: print(time.gmtime()) print("severe problem", e) # continue print('rate_error: ', rate_error) return new_tweets, rate_error
def main(keywords): api = create_api() tweets_listener = FavRetweetListener(api) stream = tweepy.Stream(api.auth, tweets_listener) stream.filter(track=keywords, languages=["en"])
def on_error(self, status): """Called when a non-200 status code is returned""" if status == 420: self.on_timeout() def on_timeout(self): """ Limit Timeout """ logger.warning("API Reach its limit, sleep for 10 minutes") time.sleep(600) return if __name__ == '__main__': listen = TwitterStream() stream = tweepy.Stream(auth, listen) move = True while move: try: logger.info('Start Loop') stream.filter( locations=[141.157913, -38.022041, 146.255569, -36.412349]) move = False logger.info('Finish Loop') except Exception as e: logger.error('Error found') logger.error(e) loop = True stream.disconnect() time.sleep(600) continue