def getTweetsByUser(username, amountOfTweets):
'''
Get the last 3 hours tweets contents and do data analysis with it.
'''
#authroization
auth = OAuthHandler(consumer_key, consumer_secret)
#access to user's key
auth.set_access_token(access_token, access_token_secret)
#calling API
api = tweepy.API(auth)
#extracted desired amount of tweet
tweets = api.user_timeline(
screen_name=username,
count=amountOfTweets,
tweet_mode='extended',
)
result = []
for info in tweets:
temp = {}
temp['id'] = str(info.id)
temp['created_at'] = info.created_at.strftime("%m/%d/%Y at %H o'clock")
temp['full_text'] = info.full_text
result.append(temp)
return result
#=================test script=================
# print getTweetsByUser("cnn", 5)
def send_tweets(c_socket):
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_SECRET)
twitter_stream = Stream(auth, TweetsListener(c_socket))
twitter_stream.filter(track=['football'
]) # this is the topic we are interested in
def get_tweets():
access_token = settings.TWITTER_ACCESS_TOKEN
access_token_secret = settings.TWITTER_ACCESS_SECRET
auth = OAuthHandler(
settings.TWITTER_OAUTH_CONSUMER_KEY,
settings.TWITTER_OAUTH_CONSUMER_SECRET,
)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
twitter_users = [
settings.TWITTER_DEPT_USER,
settings.TWITTER_PERM_SEC_USER,
]
tweets = []
for twitter_user in twitter_users:
if not twitter_user:
continue
for status in tweepy.Cursor(
api.user_timeline,
screen_name=twitter_user,
include_rts=False,
exclude_replies=True,
).items(5):
tweets.append(status)
return tweets
def request(self, method, route, params=None, json=None, user_auth=False):
host = "https://api.twitter.com"
headers = {"User-Agent": self.user_agent}
auth = None
# TODO: Ability to choose app or user auth
if user_auth:
auth = OAuthHandler(self.consumer_key, self.consumer_secret)
auth.set_access_token(self.access_token, self.access_token_secret)
auth = auth.apply_auth()
else:
headers["Authorization"] = f"Bearer {self.bearer_token}"
# TODO: log.debug
with self.session.request(
method, host + route, params=params, json=json, headers=headers,
auth=auth
) as response:
# TODO: log.debug
if response.status_code in (400, 403):
print(response.status_code)
# TODO: Handle
elif response.status_code != 200:
print(response.status_code)
# TODO: Handle
# TODO: Handle rate limits
return response.json()
def startStream(topicDict, keywords, users, locationDict):
print('Starting stream using', keywords)
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
print('Authorization successful: ', auth.oauth.verify)
while True:
twitter_stream = Stream(auth,
TweetsListener(topicDict, locationDict, users))
try:
twitter_stream.filter(languages=['en'],
track=keywords,
follow=users) # start the stream
except KeyboardInterrupt:
print('Keyboard Interrupt')
return True
except Exception as e:
print(e)
print("IM HERE")
continue
finally:
# we do this because tweepy streams never actually clear their queued tweets when they stop/crash
# this way if something goes wrong we start fresh. We might lose some data but at least it'll keep running
del twitter_stream
def trends(channel='assignment1', scheduled=True):
consumer_key = environ.get('consumer_key', None)
consumer_secret = environ.get('consumer_secret', None)
access_token = environ.get('access_token', None)
access_token_secret = environ.get('access_token_secret', None)
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = API(auth)
WOE_ID = 1
trends = api.trends_place(WOE_ID)
trends = json.loads(json.dumps(trends, indent=1))
trendy = []
for trend in trends[0]["trends"]:
trendy.append((trend["name"]))
trending = ', \n'.join(trendy[:10])
if scheduled:
slack_client.api_call("chat.postMessage",
channel=channel,
text=trending)
else:
return trending
def send_tweets(c_socket):
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
twitter_stream = Stream(auth, TweetsListener(c_socket))
twitter_stream.filter(track=['football'
]) # this is the topic we are interested in
def search_for_hashtags(consumer_key, consumer_secret, access_token,
access_token_secret, hashtag_phrase):
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
#initialize Tweepy API
api = tweepy.API(auth)
#get the name of the spreadsheet we will write to
fname = '_'.join(re.findall(r"#(\w+)", hashtag_phrase))
#open the spreadsheet we will write to
with open('%s.csv' % (fname), 'w') as file:
w = csv.writer(file)
#write header row to spreadsheet
w.writerow([
'timestamp', 'tweet_text', 'username', 'all_hashtags',
'followers_count'
])
#for each tweet matching our hashtags, write relevant info to the spreadsheet
for tweet in tweepy.Cursor(api.search, q=hashtag_phrase+' -filter:retweets', \
lang="en", tweet_mode='extended').items(100):
w.writerow([
tweet.created_at,
tweet.full_text.replace('\n', ' ').encode('utf-8'),
tweet.user.screen_name.encode('utf-8'),
[e['text'] for e in tweet._json['entities']['hashtags']],
tweet.user.followers_count
])
def get_verification():
#get the verifier key from the request url
verifier = request.args['oauth_verifier']
print(verifier)
auth = OAuthHandler(CONSUMER_TOKEN, CONSUMER_SECRET)
auth.request_token = {
'oauth_token': request.args.get('oauth_token'),
'oauth_token_secret': request.args.get('oauth_verifier')
}
# token = session['request_token']
del session_t['request_token']
# auth.set_request_token(token[0], token[1])
try:
auth.get_access_token(verifier)
print('obtuve el access token')
print(auth.access_token)
print(auth.access_token_secret)
print('termine')
except tweepy.TweepError:
print('Error! Failed to get access token.')
#now you have access!
api = tweepy.API(auth)
#store in a db
bdd['api'] = api
bdd['access_token_key'] = auth.access_token
bdd['access_token_secret'] = auth.access_token_secret
print(bdd)
return flask.redirect(flask.url_for('start'))
def trends(channel='assignment1', scheduled=True):
#consumer_key = environ.get('consumer_key', None)
#consumer_secret = environ.get('consumer_secret', None)
#access_token = environ.get('access_token', None)
#access_token_secret = environ.get('access_token_secret', None)
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = API(auth)
# Where On Earth ID for Philippines is 1187115.
# Where On Earth ID for Worldwide 1.
WOE_ID = 23424934
trends = api.trends_place(WOE_ID)
trends = json.loads(json.dumps(trends, indent=1))
trendy = []
for trend in trends[0]["trends"]:
trendy.append((trend["name"]))
trending = ', \n'.join(trendy[:10])
if scheduled:
slack_client.api_call("chat.postMessage",
channel=channel,
text=trending)
return trending
def cmd_verify(bot, update, args, chat):
if restrict_access(bot, update):
return
if not chat.twitter_request_token:
bot.reply(update, "Use /auth command first")
return
if len(args) < 1:
bot.reply(update, "No verifier code specified")
return
verifier_code = args[0]
auth = OAuthHandler(bot.tw.auth.consumer_key, bot.tw.auth.consumer_secret)
auth.request_token = json.loads(chat.twitter_request_token)
try:
auth.get_access_token(verifier_code)
except TweepError:
bot.reply(update, "Invalid verifier code. Use /auth again")
return
chat.twitter_token = auth.access_token
chat.twitter_secret = auth.access_token_secret
chat.save()
bot.reply(update, "Access token setup complete")
api = tweepy.API(auth)
settings = api.get_settings()
tz_name = settings.get("time_zone", {}).get("tzinfo_name")
cmd_set_timezone(bot, update, [tz_name])
def cmd_verify(update: telegram.Update, context: CallbackContext) -> None:
args = context.args
bot = context.bot
chat, _created = TelegramChat.get_or_create(
chat_id=update.message.chat.id,
tg_type=update.message.chat.type,
)
if not chat.twitter_request_token:
bot.reply(update, "Use /auth command first")
return
if len(args) < 1:
bot.reply(update, "No verifier code specified")
return
verifier_code = args[0]
auth = OAuthHandler(bot.tw.auth.consumer_key, bot.tw.auth.consumer_secret)
auth.request_token = json.loads(chat.twitter_request_token)
try:
auth.get_access_token(verifier_code)
except TweepyException:
bot.reply(update, "Invalid verifier code. Use /auth again")
return
chat.twitter_token = auth.access_token
chat.twitter_secret = auth.access_token_secret
chat.save()
bot.reply(update, "Access token setup complete")
api = tweepy.API(auth)
settings = api.get_settings()
tz_name = settings.get("time_zone", {}).get("tzinfo_name")
def send_tweets(c_socket):
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
twitter_stream = Stream(auth, TweetsListener(c_socket))
twitter_stream.filter(track=['Iran'
]) # este es el tema que nos interesa buscar
def _oauth_init(self):
self._oauth = OAuthHandler(social_keys.TWITTER_CONSUMER_KEY,
social_keys.TWITTER_CONSUMER_SECRET)
self._oauth.set_access_token(
social_keys.TWITTER_APP_ACCESS_TOKEN,
social_keys.TWITTER_APP_ACCESS_TOKEN_SECRET)
self._oauth_api = API(self._oauth)
def get_oauth():
conf = ConfigParser.SafeConfigParser()
conf.read("twitter.ini")
auth = OAuthHandler(conf.get("Twitter", "CK"), conf.get("Twitter", "CS"))
auth.set_access_token(conf.get("Twitter", "AT"), conf.get("Twitter", "AS"))
return auth
def send_tweets(c_socket):
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
twitter_stream = Stream(auth, TweetStreamListener(c_socket))
twitter_stream.filter(
languages=["nl"],
track=['de', 'het', 'een', 'is', 'ben', 'zijn', 'word', 'werd'])
def get_oauth(init):
consumer_key = init['consumer_key']
consumer_secret = init['consumer_secret']
access_key = init['access_key']
access_secret = init['access_secret']
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
def __init__(self, access_token, access_token_secret, consumer_key,
consumer_secret):
self.analyser = SentimentIntensityAnalyzer()
self.auth_handler = OAuthHandler(consumer_key, consumer_secret)
self.auth_handler.set_access_token(access_token, access_token_secret)
self.api = API(self.auth_handler,
wait_on_rate_limit=True,
wait_on_rate_limit_notify=True)
def _get_rate_limit_status(self, key, secret):
"""
Get rate limit status for specified access token key.
"""
auth = OAuthHandler(self.consumer_key, self.consumer_secret)
auth.set_access_token(key, secret)
api = API(auth)
return api.rate_limit_status()
def setup_listener(MEDIOS):
auth = 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(MEDIOS))
streamer.filter(track=MEDIOS)
def get_oauth():
consumer_key = 'TWITTER_CONSUMER_KEY'
consumer_secret = 'TWITTER_CONSUMER_SECRET'
access_key = 'TWITTER_ACCESS_KEY'
access_secret = 'TWITTER_ACCESS_SECRET'
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
def get_oauth():
consumer_key = "cJXMUBcenymJSgUPfnyHYVBqd"
consumer_secret = "JZbjCP6MzUnWLOoU6K2VouCpacmCwvYLmyXMY6wZzR6MyepvsN"
access_key = "46786366-3BrGV7f5vOXlLMMhrPG32Y3tIQBJ14qiG5rnNVDPo"
access_secret = "CMOZ61hlhuvDsddbeiYC9Qi34vXkrvyJhZa1v2AFrD3UK"
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
def __init__(self):
auth = OAuthHandler(API_KEY, API_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.api = tweepy.API(auth)
self.username = self.api.me().screen_name
self.max_tweet_len = 270 # the limit is 280 but twitter counts some characters as 2
self.max_reply_len = self.max_tweet_len - len(self.username) - 2
def get_oauth():
consumer_key = consumer['key']
consumer_secret = consumer['secret']
access_token = token['token']
access_secret = token['secret']
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
return auth
def send_tweets(c_socket):
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
twitter_stream = Stream(auth, TweetsListener(c_socket))
twitter_stream.filter(
locations=[-180, -90, 180,
90]) # this is the topic we are interested in
def get_oauth():
consumer_key = ''
consumer_secret = ''
access_key = ''
access_secret = ''
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
def get_oauth():
consumer_key = config.get(CONFIG_SECTION, 'TWITTER_CONSUMER_KEY')
consumer_secret = config.get(CONFIG_SECTION, 'TWITTER_CONSUMER_SECRET')
access_key = config.get(CONFIG_SECTION, 'TWITTER_ACCESS_KEY')
access_secret = config.get(CONFIG_SECTION, 'TWITTER_ACCESS_SECRET')
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
def cmd_get_auth_url(bot, update, chat):
auth = OAuthHandler(bot.tw.auth.consumer_key, bot.tw.auth.consumer_secret)
auth_url = auth.get_authorization_url()
chat.twitter_request_token = json.dumps(auth.request_token)
chat.save()
msg = "go to [this url]({}) and send me your verifier code using /verify code"
bot.reply(update,
msg.format(auth_url),
parse_mode=telegram.ParseMode.MARKDOWN)
def sendData(c_socket):
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
twitter_stream = Stream(auth, TweetsListener(c_socket))
twitter_stream.filter(track=[
'donald', 'Trump', 'US2020', 'USelection', '2020Election', 'Biden',
'JoeBiden', 'DonaldTrump'
])
def get_oauth():
# 以下4つのキー等は適宜取得して置き換えてください。
consumer_key = "E7PLfevrHNVI9ozuQlF6xXDgG"
consumer_secret = "CfobRZOWqXvPytSbn3zUDklsS81bUWXJjd3RIEYcUKnOnd1kQx"
access_key = "721661385977909249-wtx82HRTTSzm1mJgOnW0vbjR13tWCOr"
access_secret = "uFeckhWHjU5JHBOGIvPLEHQgSbfRk3SjrxUBMyLNRNh7X"
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
