def sentimentComparison(server, query1 = 'python', query2 = 'javascript', count = 50):
# Keep tabs on the number of entries
numEntries = 1
positiveSentiment = ' :)'
negativeSentiment = ' :('
h_plus = TwitterRestPager(api, 'search/tweets', {'q':joinAndEncode([query1, positiveSentiment]), 'count':count})
h_minus = TwitterRestPager(api, 'search/tweets', {'q':joinAndEncode([query1, negativeSentiment]), 'count':count})
d_plus = TwitterRestPager(api, 'search/tweets', {'q':joinAndEncode([query2, positiveSentiment]), 'count':count})
d_minus = TwitterRestPager(api, 'search/tweets', {'q':joinAndEncode([query2, negativeSentiment]), 'count':count})
tweets_list = [h_plus, h_minus, d_plus, d_minus]
tweets_titles = ['h+', 'h-', 'd+', 'd-']
tweets_lengths = []
t1 = Thread(target=iterateTweets, args=(tweets_titles[0], r_server, h_plus))
t2 = Thread(target=iterateTweets, args=(tweets_titles[1], r_server, h_minus))
t3 = Thread(target=iterateTweets, args=(tweets_titles[2], r_server, d_plus))
t4 = Thread(target=iterateTweets, args=(tweets_titles[3], r_server, d_minus))
t1.start()
t2.start()
t3.start()
t4.start()
print 'sentimentComparison() complete!'
return
def search_tweets(term):
count = 0
r = TwitterRestPager(get_twitter(), 'search/tweets', {
'q': term,
'count': COUNT,
'lang': 'en'
})
for r in r.get_iterator():
if 'message' in r and r['code'] == 88:
print('Got error... Sleeping for 15 minutes.')
sys.stderr.flush()
time.sleep(61 * 15)
d = {}
d['id'] = r['id_str']
d['screen_name'] = r['user']['screen_name']
d['screen_id'] = r['user']['id_str']
d['tweet'] = r['text']
d['followcount'] = r['user']['friends_count']
d['user_mentions'] = [
user['id_str'] for user in r['entities']['user_mentions']
]
if d['user_mentions']:
if len(d['user_mentions']) > 1:
save_to_file(d)
count += 1
if count > COUNT - 1:
break
return count
def count_tweets(hashtags):
"""connect to the Twitter API and get our counts for each expression"""
#substitute your API and ACCESS credentials
api = TwitterAPI('API_KEY','API_SECRET','ACCESS_TOKEN','ACCESS_TOKEN_SECRET')
all_counts = [] #a list of counts for all hashtags
for hashtag in hashtags #iterate through hashtags
hashtag_count = 0 #count for one hashtag
an_hour_ago = datetime.now() - timedelta(hours = 1) #set time for 1 hour ago
#we use search/tweets, a REST API endpoint that closes after returning a maximum of 100
#recent tweets and supports paging
#TwitterRestPager spaces out successive requests to stay under Twitter API the rate limit
r = TwitterRestPager(api, 'search/tweets', {'q':'#{}'.format(hashtag), 'count': 100})
for item in r.get_iterator(wait=6): #increase the wait interval to 6 seconds
if 'text' in item:
hashtag_count += 1
#in case we exceed the rate limit, error 88 indicates how long to suspend before
#making a new request
elif 'message' in item and item['code'] == 88:
print('SUSPEND, RATE LIMIT EXCEEDED: %s' % item['message'])
break
#covert time when each tweet was created to a datatime type
created = datetime.strptime(item['created_at'], '%a %b %d %H:%M:%S +0000 %Y')
if created <= an_hour_ago: #finish counting if created more than an hour ago
hashtag_count -= 1 #and don't count that tweet
break
all_counts.append(hashtag_count) #add a count for one hashtag to our list
return all_counts
def get_paged_timeline(api: TwitterAPI, count: int = 500):
"""
Returns an iterator of pages of the timeline. The iterator has higher capacity and scrolls.
:param api: Must be a User auth'd TwitterAPI.
:param count: number of tweets to display
:return: the iterator of timeline tweets
"""
timeline = TwitterRestPager(api, 'status/home_timeline', {'count': count})
return timeline.get_iterator()
def tweet_producer():
kafka = KafkaClient(KAFKA_BROKER)
producer = SimpleProducer(kafka)
while True:
try:
api = TwitterAPI(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN_KEY,
ACCESS_TOKEN_SECRET)
print('Using search term: %s' % SEARCH_TERM, file=sys.stderr)
pager = TwitterRestPager.TwitterRestPager(api, 'search/tweets',
{'q': SEARCH_TERM})
for item in pager.get_iterator():
if 'text' in item:
tweet = {}
tweet['id'] = item['id']
# tweet['coordinates'] = item['coordinates']
#rhoover: the mktime/strptime below is incorrect (making times in the future) so using this for now
tweet['@timestamp'] = int(time.time() * 1000.0)
tweet['created_at'] = time.strftime(
'%Y-%m-%d %H:%M:%S',
time.strptime(item['created_at'],
'%a %b %d %H:%M:%S +0000 %Y'))
# tweet['@timestamp'] = time.mktime(time.strptime(item['created_at'],"%a %b %d %H:%M:%S +0000 %Y")) * 1000
# tweet['place'] = item['place']
# ts = time.strftime('%Y-%m-%d %H:%M:%S', time.strptime(item['created_at'],'%a %b %d %H:%M:%S +0000 %Y'))
# tweet['@timestamp'] = item['created_at']
tweet['username'] = item['user']['name']
tweet['handle'] = item['user']['screen_name']
tweet['lang'] = item['lang']
tweet['timezone'] = item['user']['time_zone']
tweet['followers'] = item['user']['followers_count']
tweet['location'] = item['user']['location']
tweet['retweeted'] = item['retweeted']
tweet['text'] = item['text']
producer.send_messages(b'tweets',
bytes(json.dumps(tweet), "UTF-8"))
twitter_metrics["tweets-consumed"] = twitter_metrics[
"tweets-consumed"] + 1
elif 'message' in item and item['code'] == 88:
print('SUSPEND, RATE LIMIT EXCEEDED: %s\n' %
item['message'],
file=sys.stderr)
time.sleep(120)
break
print('Consumed %s tweets' %
twitter_metrics["tweets-consumed"],
file=sys.stderr)
except:
print(traceback.format_exc(), file=sys.stderr)
print("Sleeping for 120 secs.", file=sys.stderr)
time.sleep(120)
return
def twittersearch():
pager = TwitterRestPager(api, 'search/tweets', {
'q': TRACK_TERM,
'count': 100
})
for item in pager.get_iterator(wait=6):
userid = item['user']['id']
tweetid = item['id']
print userid
print tweetid
favorite(tweetid)
follow(userid)
def rank_old_words(api, word_list, n):
words = ' OR '.join(word_list)
count = {}
while True:
pager = TwitterRestPager(api, 'search/tweets', {'q':words, 'count':COUNT})
for item in pager.get_iterator():
if 'text' in item:
process_tweet(item['text'], count, n, word_list)
elif 'message' in item:
if item['code'] == 131:
continue # ignore internal server error
elif item['code'] == 88:
print('Suspend search until %s' % search.get_quota()['reset'])
raise Exception('Message from twitter: %s' % item['message'])
def counter(hashtag, df, limit=None):
count = 0
#Initialize Twitter Rest Pager
r = TwitterRestPager(api, 'search/tweets', {'q': hashtag, 'count': 100})
#Limit Option
if limit is not None:
print("requested tweets for hashtag is limited to {} tweets".format(
limit))
for item in r.get_iterator(wait=6):
if 'text' in item:
if count <= limit:
print("collecting tweet {} of {}...".format(count, limit))
count += 1
#Extract Tweet Info
extract_tweet_info(item, count, df, hashtag)
else:
print("requested tweet limit reached...")
print("ending query for hashtag...")
return
elif 'message' in item and item['code'] == 88:
print('SUSPEND, RATE LIMIT EXCEEDED: %s' % item['message'])
break
#No Limit
else:
for item in r.get_iterator(wait=6):
if 'text' in item:
print("collecting tweet {} of all available tweets...".format(
count))
count += 1
#Extract Tweet Info
extract_tweet_info(item, count, df, hashtag)
elif 'message' in item and item['code'] == 88:
print('SUSPEND, RATE LIMIT EXCEEDED: %s' % item['message'])
break
def harvest_friends():
# get a user Id from database
user_id = db_client.find_user_for_friends()
api = TwitterAPI(
consumer_key=Auth[token_number]['consumer_key'],
consumer_secret=Auth[token_number]['consumer_secret'],
access_token_key=Auth[token_number]['access_token_key'],
access_token_secret=Auth[token_number]['access_token_secret'],
auth_type='oAuth1')
cursor = -1
# while 1:
try:
count = 0
# r = api.request('friends/list', {"user_id": user_id, 'count': 200, 'cursor': cursor})
r2 = TwitterRestPager(api, 'friends/list', {
"user_id": user_id,
'count': 200
})
for each_user_info in r2.get_iterator(40):
FileSave(each_user_info)
except TwitterRequestError as e:
print(e.status_code)
if e.status_code < 500:
if e.status_code == 429 or e.status_code == 420:
print('I am sleeping')
time.sleep(450)
elif e.status_code == 401:
pass
else:
raise
print('TwitterRequestError')
# something needs to be fixed before re-connecting
pass
else:
print('TwitterRequestError')
# temporary interruption, re-try request
pass
# TwitterConnectionError is thrown when the connection times out or is interrupted.
# You can always immediately try making the request again.
except TwitterConnectionError:
print('disconnected from Twitter Connection Error')
# temporary interruption, re-try request
pass
except Exception as e:
print(Exception)
pass
def _get_pager(self):
'''Returns a paginating object over tweets'''
config = self._load_config()
api = TwitterAPI(
config['consumer_key'], # app-only auth
config['consumer_secret'],
auth_type='oAuth2')
self.cache = config.get('cache', NUM_CACHE_TWEETS)
query = config.get('query')
assert query, 'expected a search query in config'
params = {'q': query, 'count': TWEETS_PER_BATCH}
self._log('Query: %r' % params)
return TwitterRestPager(api, SEARCH_ENDPOINT, params)
def search_user():
keepdoing = True
while keepdoing:
try:
# get a user ID
user_id = db_client.find_user_for_tweeets()
api = TwitterAPI(consumer_key=Auth[token_number]['consumer_key'],
consumer_secret=Auth[token_number]['consumer_secret'],
access_token_key=Auth[token_number]['access_token_key'],
access_token_secret=Auth[token_number]['access_token_secret'],
auth_type='oAuth2')
# r = api.request('statuses/user_timeline', {"user_id": user_id, 'count': 200, 'exclude_replies': 'true'})
# Use the
r = TwitterRestPager(api, 'statuses/user_timeline', {"user_id": user_id, 'count': 200, 'exclude_replies': 'true'})
for each in r.get_iterator():
if 'text' in each:
FileSave(each)
except TwitterRequestError as e:
print(e.status_code)
if e.status_code < 500:
if e.status_code == 429 or e.status_code == 420:
print('I am sleeping')
time.sleep(450)
elif e.status_code == 401:
pass
else:
raise
print('TwitterRequestError')
# something needs to be fixed before re-connecting
pass
else:
print('TwitterRequestError')
# temporary interruption, re-try request
pass
# TwitterConnectionError is thrown when the connection times out or is interrupted.
# You can always immediately try making the request again.
except TwitterConnectionError:
print('disconnected from Twitter Connection Error')
# temporary interruption, re-try request
pass
except Exception as e:
print(Exception)
pass
def search(request):
# form = DateForm(request.GET)
query = request.GET['q']
date = request.GET['date']
formatted_date = datetime.strptime(date, '%m/%d/%Y').strftime('%Y-%m-%d')
# json_string = api.request('search/tweets', {'q': '%23' + query + ' since:2016-05-11'})
# decoded_json = json_string.json()
r = TwitterRestPager(api, 'search/tweets', {
'q': '%23' + query + ' since:' + formatted_date,
'count': 100
})
maxRT = 0
tweet = {}
count = 0
for item in r.get_iterator(wait=2):
print(item['text'])
if 'text' in item:
if item['retweet_count'] > maxRT:
tweet = {
'text': item['text'],
'rt_count': item['retweet_count']
}
count += 1
elif 'message' in item and item['code'] == 88:
print('SUSPEND, RATE LIMIT EXCEEDED: %s' % item['message'])
break
print(count)
# pdb.set_trace()
#
#
# for item in decoded_json['statuses']:
# print(item['text'])
# c = Context({'results': decoded_json['statuses']})
t = loader.get_template('results.html')
c = Context({'count': count, 'tweet': tweet})
return HttpResponse(t.render(c))
def Searching():
api = TwitterAPI(consumer_key=Auth[token_number]['consumer_key'],
consumer_secret=Auth[token_number]['consumer_secret'],
access_token_key=Auth[token_number]['access_token_key'],
access_token_secret=Auth[token_number]['access_token_secret'],
auth_type='oAuth2')
#https://dev.twitter.com/rest/reference/get/search/tweets
#result_type: 'mixed' 'recent' 'popular'
# come with the cursor of Max_id
r=TwitterRestPager(api,'search/tweets',{'q':search_words,
'geocode':geo_for_searching +',50km',
'result_type':'mixed',
'count':100,
})
for item in r.get_iterator():
FileSave(item)
twitter_log("searching_finished")
def Searching():
api = TwitterAPI(consumer_key=Auth[token_number]['consumer_key'],
consumer_secret=Auth[token_number]['consumer_secret'],
access_token_key=Auth[token_number]['access_token_key'],
access_token_secret=Auth[token_number]['access_token_secret'],
auth_type='oAuth2')
#https://dev.twitter.com/rest/reference/get/search/tweets
#result_type: 'mixed' 'recent' 'popular'
# come with the cursor of Max_id
r=TwitterRestPager(api,'search/tweets',{'q':search_words,
'geocode':geo_for_searching +',50km',
'result_type':'mixed',
'count':10000,
})
count=1
for item in r.get_iterator():
if 'text' in item:
id_list.put(item['user']['id_str'])
print('Now queue size is %d' % id_list.qsize())
def search_tweets(api, word_list, photo_dir, region, stalk, no_retweets,
count):
"""Get tweets containing any words in 'word_list'."""
words = ' OR '.join(word_list)
params = {'q': words, 'count': count}
if region:
params['geocode'] = '%f,%f,%fkm' % region # lat,lng,radius
while True:
pager = TwitterRestPager(api, 'search/tweets', params)
for item in pager.get_iterator():
if 'text' in item:
if not no_retweets or not item.has_key('retweeted_status'):
process_tweet(item, photo_dir, stalk)
elif 'message' in item:
if item['code'] == 131:
continue # ignore internal server error
elif item['code'] == 88:
print('Suspend search until %s' %
search.get_quota()['reset'])
raise Exception('Message from twitter: %s' % item['message'])
def twitter_to_csv(q, limit=500):
consumer_key = settings.TWITTER_CONSUMER_KEY
consumer_secret = settings.TWITTER_CONSUMER_SECRET
access_token_key = settings.TWITTER_ACCESS_TOKEN_KEY
access_token_secret = settings.TWITTER_ACCESS_TOKEN_SECRET
api = TwitterAPI(consumer_key, consumer_secret, access_token_key,
access_token_secret)
output = io.StringIO()
writer = csv.writer(output)
api = TwitterAPI(consumer_key, consumer_secret, access_token_key,
access_token_secret)
count = 0
r = TwitterRestPager(api, 'search/tweets', {'q': q, 'count': 100})
for item in r.get_iterator():
if 'text' in item:
count += 1
author = item['user']['screen_name'].lower()
mentions = item['entities']['user_mentions']
text = re.sub(r'https?:\/\/.*[\r\n]*',
'',
item['text'],
flags=re.MULTILINE)
text = re.sub(r'@([A-Za-z0-9_]+)', '', text, flags=re.MULTILINE)
for mention in mentions:
writer.writerow([author, mention['screen_name'].lower(), text])
if len(mentions) == 0:
writer.writerow([author, author, text])
elif 'message' in item and item['code'] == 88:
print('SUSPEND, RATE LIMIT EXCEEDED: %s\n' % item['message'])
break
if count > limit:
break
print('Twitter search for', q, '; results:', count)
return output.getvalue()
def harvest_friends():
num = 1
# get a user Id from database
user_id = "40814404"
api = TwitterAPI(
consumer_key=Auth[token_number]['consumer_key'],
consumer_secret=Auth[token_number]['consumer_secret'],
access_token_key=Auth[token_number]['access_token_key'],
access_token_secret=Auth[token_number]['access_token_secret'],
auth_type='oAuth1')
cursor = -1
# while 1:
r2 = TwitterRestPager(api, 'followers/list', {
"user_id": user_id,
'count': 200
})
r = api.request('followers/list', {"user_id": user_id, 'count': 200})
for each_user_info in r2.get_iterator():
if 'Australia' in each_user_info['location']:
num += 1
print(num)
def get_score(self, gene):
"""
:param gene
:return: Number of resent tweets of the gene symbol (plus likes and re-tweeks)
"""
score = 0
twitter_query = '{name} gene OR genomics'.format(name=gene.name)
# REST API endpoint that closes after returning a maximum of 100 recent tweets.
# TwitterRestPager spaces out successive requests to stay under the rate limit of 5s between calls.
tweets = TwitterRestPager(self.api, 'search/tweets', {
'q': twitter_query,
'count': 100
})
for tweet in tweets.get_iterator(wait=6):
if 'retweeted_status' not in tweet:
score += int(tweet['retweet_count']) + int(
tweet['favorite_count']) + 1
sleep(6)
return score
def makeDB(word='analytics'):
o = read_file()
api = TwitterAPI(o['consumer_key'],o['consumer_secret'],o['access_token_key'],o['access_token_secret'])
r = TwitterRestPager(api, 'search/tweets', {'q': word,'count':100})
d=dict((v,k) for k,v in enumerate(calendar.month_abbr))
try:
flag = 0
for item in r.get_iterator():
if flag ==100:
break
flag+=1
obj = User(U_id = item['user']['id'])
obj.name = item['user']['screen_name']
obj.location = item['user']['time_zone']
x=list(map(str,item['user']['created_at'].split(' ')))
obj.date = datetime.strptime(x[2] + str(d[x[1]]) + x[-1], "%d%m%Y").date()
obj.text = item['text']
obj.search = word
obj.save()
except:
print "Request cannot be served due to the application's rate limit having been exhausted for the resource"
def pagingCall(server, query='blockchain', key='Tweets', count = 200, limit = 200):
# Keep tabs on the number of entries
numEntries = 1
r = TwitterRestPager(api, 'search/tweets', {'q':query, 'count':count})
for item in r.get_iterator():
if 'text' in item:
# Pass-in tweets into a list
server.rpush(key, re.sub(r"http\S+", "", item['text']))
if(numEntries % 100 == 0):
print 'Entries so far', numEntries
#printValues(server, key)
if(numEntries == limit):
break
# Move on to the next entry
numEntries += 1
elif 'message' in item and item['code'] == 88:
print 'SUSPEND, RATE LIMIT EXCEEDED: %s\n' % item['message']
break
return
BITLY_USERNAME = '******'
BITLY_API_KEY = 'R_19bff5294a094749a4177d9f639b7637'
BITLY_ACCESS_TOKEN = 'c6869fe932e2b5b912d97382c885fb8df8ba2bd8'
FOURSQUARE_ACCESS_TOKEN = 'K44DQZABARQM2HM2ETXZZHLXY11KYXAHAKY3NB0BN15KBN0Z'
api = TwitterAPI(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN_KEY,
ACCESS_TOKEN_SECRET)
bitly = bitly_api.Connection(access_token=BITLY_ACCESS_TOKEN)
#eastern = timezone('US/Eastern')
#utc = timezone('UTC')
pager = TwitterRestPager(api, 'search/tweets', {'q': SEARCH_TERM})
def get_checkid_and_s(url):
checkin_index = url.find('checkin')
mark_s_index = url.find('?s=')
check_id = url[checkin_index + 8:mark_s_index]
refer_ref_index = url.find('&ref')
signature_id = url[mark_s_index + 3:refer_ref_index]
return check_id, signature_id
def get_check_in_info(id, sig):
dt = date.today()
WORDS_TO_COUNT = ['lion', 'wildbeest', 'snake']
API_KEY = 'NZow9q4lgFxhPw2omwqJ2VtIj'
API_SECRET = 'r5fYLio2Da9T6n9TcgasSWLuTV0KPkInOo4mddSfotNX9VfArM'
ACCESS_TOKEN = '1538574218-U5Y8z6DsJJKT0xwHBqIs4tygi048fBLwtwMgNtU'
ACCESS_TOKEN_SECRET = 'cKeAv9F67ckA8UynkGalpzaQTwtx2NAjWTwt2DtR20VpN'
api = TwitterAPI(API_KEY, API_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
words = ' OR '.join(WORDS_TO_COUNT)
counts = dict((word,0) for word in WORDS_TO_COUNT)
def process_tweet(text):
text = text.lower()
for word in WORDS_TO_COUNT:
if word in text:
counts[word] += 1
print(counts)
r = TwitterRestPager(api, 'search/tweets', {'q':words, 'count':100})
for item in r.get_iterator(wait=6):
if 'text' in item:
process_tweet(item['text'])
elif 'message' in item and item['code'] == 88:
print('\n*** SUSPEND, RATE LIMIT EXCEEDED: %s\n' % item['message'])
break
DK_names = data_DK["Name"]
#Concatenate the batters and pitchers and drop dups
frames = [pitchers_names, batters_names]
all_players = pd.concat(frames)
all_players = all_players.drop_duplicates()
#Do some data cleaning so that the Data is easier to match up later
cleanplayerlst = []
for i in list(batters_names):
test = i.split(",")
test[0], test[1] = test[1], test[0]
test = test[0].strip() + " " + test[1]
cleanplayerlst.append(test)
#build list of iterators
iterator_list = [
TwitterRestPager(api, 'search/tweets', {
'q': name
}).get_iterator(wait=2) for name in cleanplayerlst
]
player_dict = defaultdict(list)
count = 0
try:
for player, iterator in enumerate(iterator_list):
count += 1
print "Player Count:", count
if player != 0 and player % 60 == 0:
time.sleep(1200)
for idx, item in enumerate(iterator):
if idx == 40:
break
if 'text' in item:
player_dict[cleanplayerlst[player]].append(item['text'])
from secrets import consumer_key, consumer_secret, access_token_key, access_token_secret
api = TwitterAPI(consumer_key, consumer_secret, access_token_key,
access_token_secret)
data_followers = json.load(open('followers.json'))
main_account = sys.argv[1]
while True:
try:
if main_account not in data_followers or len(
data_followers[main_account]) == 2000:
print('followers/', main_account)
r = TwitterRestPager(api, 'followers/list', {
'screen_name': main_account,
'count': 200
})
data_followers[main_account] = []
for item in r.get_iterator(wait=60):
data_followers[main_account].append(item)
if len(data_followers[main_account]) % 200 == 0:
print('....', len(data_followers[main_account]))
print(' ->', len(data_followers[main_account]))
json.dump(data_followers,
open('followers.json', 'w'),
indent=2,
sort_keys=True,
ensure_ascii=False)
break
except TwitterError.TwitterRequestError as e:
print(e)
access_token_secret)
# This is a dictionary that holds the amount of mentions in a given hour
dictionary = {"Jan":{8:{0:0, 1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0, 8:0, 9:0, 10:0, \
11:0, 12:0, 13:0, 14:0, 15:0, 16:0, 17:0, 18:0, 19:0, 20:0, 21:0, \
22:0, 23:0}, \
7:{0:0, 1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0, 8:0, 9:0, 10:0, \
11:0, 12:0, 13:0, 14:0, 15:0, 16:0, 17:0, 18:0, 19:0, 20:0, 21:0, \
22:0, 23:0}}}
api = TwitterAPI.TwitterAPI(consumer_key, consumer_secret, access_token,
access_token_secret)
# Using Ethereum because it's a little bit less well known than bitcoin and
# and should have far fewer tweets, thus more manageable for me to test
# Also, the Twitter API limits the amount of queries per second, so this
# is capped out to run 100 every 6 seconds. Kinda slow to run on something
# with as many mentions as bitcoin
r = TwitterRestPager(api, 'search/tweets', {'q': 'ethereum', 'count': 100})
for item in r.get_iterator(wait=6):
time_stamp = item['created_at']
month = time_stamp[4:7]
day = int(time_stamp[8:10])
hour = int(time_stamp[11:13])
if ('text' in item):
dictionary[month][day][hour] += 1
elif 'message' in item and item['code'] == 88:
print('SUSPEND, RATE LIMIT EXCEEDED: %s' % item['message'])
break
print(dictionary)
if TEST_NUMBER == 1:
# POST A TWEET
r = api.request('statuses/update',
{'status': 'the time is now %s' % datetime.now()})
print(r.status_code)
if TEST_NUMBER == 2:
# GET 5 TWEETS CONTAINING 'ZZZ'
for item in api.request('search/tweets', {'q': 'zzz', 'count': 5}):
print(item['text'] if 'text' in item else item)
if TEST_NUMBER == 3:
# STREAM TWEETS FROM AROUND NYC
for item in api.request('statuses/filter',
{'locations': '-74,40,-73,41'}):
print(item['text'] if 'text' in item else item)
if TEST_NUMBER == 4:
# GET TWEETS FROM THE PAST WEEK OR SO CONTAINING 'LOVE'
pager = TwitterRestPager(api, 'search/tweets', {'q': 'love'})
for item in pager.get_iterator():
print(item['text'] if 'text' in item else item)
except Exception as e:
print(e)
worksheet.write(0, 6, 'Favourited')
worksheet.write(0, 7, 'Image URL')
# Set up initial count and default data
count = 0
user = '******'
imageUrl = 'No image'
text = 'No text'
retweeted = 'false'
retweetCount = 0
createdAt = 'No time'
favorited = 'false'
# Return tweets, 100 at a time, with our chosen query (for hashtags, use "%23" to encode the hashtag character)
r = TwitterRestPager(api, 'search/tweets', {
'q': '%23SomeHashtag',
'count': 100
})
# Loop through each item in the response, waiting 6 seconds between each request (as this should avoid our hourly limit)
for item in r.get_iterator(wait=6):
# If we have text within this item then the tweet is valid
if 'text' in item:
# Update our variables
count += 1
text = item['text']
retweeted = item['retweeted']
retweetCount = item['retweet_count']
createdAt = item['created_at']
favorited = item['favorited']
entities = item['entities']
userObject = item['user']
# Print a user's timeline. This will get up to 3,200 tweets, which
# is the maximum the Twitter API allows.
from TwitterAPI import TwitterAPI, TwitterRestPager
SCREEN_NAME = 'TheTweetOfGod'
api = TwitterAPI(<consumer key>,
<consumer secret>,
auth_type='oAuth2')
pager = TwitterRestPager(api,
'statuses/user_timeline',
{'screen_name':SCREEN_NAME, 'count':200})
count = 0
for item in pager.get_iterator(wait=3.5):
if 'text' in item:
count = count + 1
print(count, item['text'])
elif 'message' in item:
print(item['message'])
break
