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)
class TweetAnalyser:
"""
Wrapper for Tweepy API and vaderSentiment.vaderSentiment
TweetAnalyser builds an abstraction between tweepy api and the twitter sentiment app
giving the developer freedom to integrate tweepy api and vaderSentiment.vaderSentiment
with a minimal change to the app code.
"""
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 search_tweets(self, q: str, lang='en', rpp=100, items=12):
"""
Return iterator for items in each page
"""
return Cursor(self.api.search, q, lang, rpp).items(items)
def get_polarity_scores(self, text: str):
"""
Return a float for sentiment strength based on the input text.
Positive values are positive valence, negative value are negative
valence.
:param text: the input text
:return: a float value sentiment strength
"""
return self.analyser.polarity_scores(text)
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=['football'
]) # this is the topic we are interested in
class TweepyStreamBackoffTests(unittest.TestCase):
def setUp(self):
#bad auth causes twitter to return 401 errors
self.auth = OAuthHandler("bad-key", "bad-secret")
self.auth.set_access_token("bad-token", "bad-token-secret")
self.listener = MockStreamListener(self)
self.stream = Stream(self.auth, self.listener)
def tearDown(self):
self.stream.disconnect()
def test_exp_backoff(self):
self.stream = Stream(self.auth, self.listener, timeout=3.0,
retry_count=1, retry_time=1.0, retry_time_cap=100.0)
self.stream.sample()
# 1 retry, should be 4x the retry_time
self.assertEqual(self.stream.retry_time, 4.0)
def test_exp_backoff_cap(self):
self.stream = Stream(self.auth, self.listener, timeout=3.0,
retry_count=1, retry_time=1.0, retry_time_cap=3.0)
self.stream.sample()
# 1 retry, but 4x the retry_time exceeds the cap, so should be capped
self.assertEqual(self.stream.retry_time, 3.0)
mock_resp = MagicMock()
mock_resp.return_value.status = 420
@patch(getresponse_location, mock_resp)
def test_420(self):
self.stream = Stream(self.auth, self.listener, timeout=3.0, retry_count=0,
retry_time=1.0, retry_420=1.5, retry_time_cap=20.0)
self.stream.sample()
# no retries, but error 420, should be double the retry_420, not double the retry_time
self.assertEqual(self.stream.retry_time, 3.0)
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 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 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()
class TweepyStreamBackoffTests(unittest.TestCase):
def setUp(self):
#bad auth causes twitter to return 401 errors
self.auth = OAuthHandler("bad-key", "bad-secret")
self.auth.set_access_token("bad-token", "bad-token-secret")
self.listener = MockStreamListener(self)
self.stream = Stream(self.auth, self.listener)
def tearDown(self):
self.stream.disconnect()
def test_exp_backoff(self):
self.stream = Stream(self.auth, self.listener, timeout=3.0,
retry_count=1, retry_time=1.0, retry_time_cap=100.0)
self.stream.sample()
# 1 retry, should be 4x the retry_time
self.assertEqual(self.stream.retry_time, 4.0)
def test_exp_backoff_cap(self):
self.stream = Stream(self.auth, self.listener, timeout=3.0,
retry_count=1, retry_time=1.0, retry_time_cap=3.0)
self.stream.sample()
# 1 retry, but 4x the retry_time exceeds the cap, so should be capped
self.assertEqual(self.stream.retry_time, 3.0)
mock_resp = MagicMock()
mock_resp.return_value.status_code = 420
@patch('requests.Session.request', mock_resp)
def test_420(self):
self.stream = Stream(self.auth, self.listener, timeout=3.0, retry_count=0,
retry_time=1.0, retry_420=1.5, retry_time_cap=20.0)
self.stream.sample()
# no retries, but error 420, should be double the retry_420, not double the retry_time
self.assertEqual(self.stream.retry_time, 3.0)
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 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
class TwitterClient():
def __init__(self, twitter_user=None):
self.auth = OAuthHandler(credentials.CONSUMER_KEY,
credentials.CONSUMER_SECRET)
self.auth.set_access_token(credentials.ACCESS_TOKEN,
credentials.ACCESS_TOKEN_SECRET)
#self.auth.Authenticate_Twitter_app()
self.twitter_client = tweepy.API(self.auth)
self.twitter_user = twitter_user
def getTwitterClientAPI(self):
return self.twitter_client
def getUserTimelineTweets(self, numTweets):
return [
tweet
for tweet in tweepy.Cursor(self.twitter_client.user_timeline,
id=self.twitter_user).items(numTweets)
]
def getFriendList(self, numFriends):
return [
friend
for friend in tweepy.Cursor(self.twitter_client.friends,
id=self.twitter_user).items(numFriends)
]
def getHomeTimeline(self, numTweets):
return [
tweet
for tweet in tweepy.Cursor(self.twitter_client.home_timeline,
id=self.twitter_user).items(numTweets)
]
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=['Iran'
]) # este es el tema que nos interesa buscar
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 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 __init__(self, api_key, api_key_secret, access_token, token_secret):
'''
Initialize the twitter API client.
'''
auth_handler = OAuthHandler(api_key, api_key_secret)
auth_handler.set_access_token(access_token, token_secret)
self.twitter_client = API(auth_handler)
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 register(request):
if request.method == 'POST':
form = FundRaiserRegistration(request.POST)
if form.is_valid():
# partially create user, and store unauthed token
user = _user_from_reg_form(form)
try:
profile = _profile_from_reg_form(form, user)
except ValueError:
return HttpResponse('that page is already registered')
request.session['user_id'] = user.pk
handler = OAuthHandler(settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
callback='http://www.justgivingthanks.com/callback/',
secure=True)
auth_url = handler.get_authorization_url()
request.session['unauthed_token'] = handler.request_token.to_string()
print 'created user, got token, redirecting to %s' % (auth_url)
return HttpResponseRedirect(auth_url)
else:
form = FundRaiserRegistration() # An unbound form
return render_to_response('registration.html',
{'form': form},
context_instance=RequestContext(request))
def filter_track(follow):
auth = OAuthHandler(consumer_key2, consumer_secret2)
auth.set_access_token(access_token2, access_token_secret2)
stream = Stream(auth, MyStreamListener())
api = API(auth)
#print 'start filter track ', ','.join(track)
stream.filter(track=follow)
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():
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 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 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 = ''
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 = "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_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 oauth():
consumer_key = ""
consumer_secret = ""
access_token = ""
access_token_secret = ""
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_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 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 = 'dTFlSvzNIkROO6BfAkTsDQ'
consumer_secret = 'UnWZeo7rxdx38aVnGhbZSdmiraNgSUnwGuTxYdrvts'
access_key = '105981624-84OpytBltuseQ1XWx2hTAlhQO9oO8IpSiSnxgL0e'
access_secret = 'Kh3xAsVLyBiEESfRVpqp1WE4KVZH2w46JlKUU5wOI'
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 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 = keys.twKeys['consumer_key'].encode('utf-8')
consumer_secret = keys.twKeys['consumer_secret'].encode('utf-8')
access_key = keys.twKeys['access_token'].encode('utf-8')
access_secret = keys.twKeys['access_secret'].encode('utf-8')
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
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 __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_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 _setup_apis(self):
auth = OAuthHandler(self._consumer_key, self._consumer_secret)
auth.set_access_token(self._access_token, self._access_token_secret)
if self._raw_json:
self._api = TwitterAPI(auth, parser=RawParser())
else:
self._api = TwitterAPI(auth)
def get_auth_url(self, params={}, callback_url=None):
if callback_url is None:
callback_url = self._callback_url
callback = '%s?%s' % (callback_url, urllib.urlencode(params))
auth = OAuthHandler(self._consumer_key, self._consumer_secret, callback)
url = auth.get_authorization_url()
return url, auth.request_token
def get_oauth(self,):
consumer_key = self.consumer['key']
consumer_secret = self.consumer['secret']
access_token = self.token['token']
access_secret = self.token['secret']
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
return auth
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 filter_track():
q = Scrapers.all().filter('','')
follow=[s.uid for s in q]
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
stream = Stream(auth, MyStreamListener())
api = API(auth)
#print 'start filter track ', ','.join(track)
stream.filter(follow=follow)
def getOauth():
CONSUMER_KEY=secret.CONSUMER_KEY
CONSUMER_SECRET=secret.CONSUMER_SECRET
ACCESS_TOKEN_KEY=secret.ACCESS_TOKEN_KEY
ACCESS_TOKEN_SECRET=secret.ACCESS_TOKEN_SECRET
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET)
return auth
def get_oauth():
# 以下4つのキー等は適宜取得して置き換えてください。
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 main_logger(basename=None):
l = RotatingLogListener(basename=basename)
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
stream = Stream(auth, l)
# This fetches ANY geotagged tweet:
# https://dev.twitter.com/docs/streaming-apis/parameters#locations
stream.filter(locations=[-180,-90,180,90])
def getOauth(): consumerKey = 'jCLoeEVXxq4ygfPsJma33jUTN' consumerSecret = 'yPSDOl17fqBqaSKfDa8rDlaHaHBZ6llyClcLRO1G3kV6cIWnWz' accessKey = '495476602-OalwRLSU9poetl3HuQiX9AZ8tcd9QQuhfHLjQ8xf' accessSecret = 'bQhekPGvSn87VmxSuPtP8ODCXFzZKJ1zoZnRvMThVLNof' auth = OAuthHandler(consumerKey, consumerSecret) auth.set_access_token(accessKey, accessSecret) return auth
def get_oauth():
consumer_key = 'JpU9Lb1PEpFtLgC7XOlkw'
consumer_secret = 'k6TsCWbybimpcBMhi8o5simuuoX3XjoMGtG5Ij9U'
access_key = '132108032-vQ58uSC6HE0IOOMtmZcRjjko4gbykAOmDF4Vg3tI'
access_secret = 'Q2uMS4NvwPhAs6BthJ19ImdYCixXmxfUos1B76D4'
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
def get(self):
verifier = self.request.GET.get('oauth_verifier')
user = users.get_current_user()
if not user:
logging.warning("current user is not logged in")
self.redirect("/")
logging.info("running callback for user: %s" % user.user_id())
social_users = model.SocialKeysForUsers.all()
social_users.filter("user_id =",user.user_id())
user_model = social_users.get()
if not user_model == None and user_model.request_token_key and user_model.request_token_secret:
try:
auth = OAuthHandler(social_keys.TWITTER_CONSUMER_KEY, social_keys.TWITTER_CONSUMER_SECRET)
auth.set_request_token(user_model.request_token_key, user_model.request_token_secret)
auth.get_access_token(verifier)
user_model.access_token_key = auth.access_token.key
user_model.access_token_secret = auth.access_token.secret
api = API(auth)
api_is_working = api.test()
user_model.shortcut_social_username = api.me().screen_name
user_model.put()
memcache.add("twitter_user:%s" % user.user_id(), user_model.shortcut_social_username, 60)
#self.response.out.write("twitter user name: %s\n" % user_model.shortcut_social_username)
logging.debug("user access tokens have been set")
self.redirect("/")
except TweepError:
logging.error( "TweepError error API is could not fetch me: %s" % user.user_id())
user_model.access_token_key = None
user_model.access_token_secret = None
user_model.put()
self.redirect(URL_STATIC_ERROR_DEFAULT)
except CapabilityDisabledError:
logging.error( "Capability Disabled Error could not write for: %s" % user.user_id())
self.redirect(URL_STATIC_ERROR_DEFAULT)
else:
logging.warning("user model is not setup correctly: %s for user % " % (user_model, user.user_id()))
self.redirect("/")
def oauth():
# Fill in your keys here:
consumer_key = 'XXXXXXXXXXXXXXXXXXXX'
consumer_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
access_key = 'XXXXXXXX-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
access_secret = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
def tweet(answer):
CONSUMER_KEY = config.get("auth", "CONSUMER_KEY")
CONSUMER_SECRET = config.get("auth", "CONSUMER_SECRET")
ACCESS_TOKEN = config.get("auth", "ACCESS_TOKEN")
ACCESS_TOKEN_SECRET = config.get("auth", "ACCESS_TOKEN_SECRET")
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
api = API(auth)
result = api.update_status(status=answer)
def get_token(self, oauth_token, oauth_token_secret, oauth_verifier):
auth = OAuthHandler(self._consumer_key, self._consumer_secret)
auth.request_token = {'oauth_token': oauth_token,
'oauth_token_secret': oauth_token_secret}
auth.get_access_token(oauth_verifier)
self._access_token = auth.access_token
self._access_token_secret = auth.access_token_secret
self._setup_apis()
return self._access_token, self._access_token_secret
def get_stream(self, listener=None):
if self._stream is not None:
self._stream.disconnect()
if listener is None:
listener = self._stream.listener
auth = OAuthHandler(self._consumer_key, self._consumer_secret)
auth.set_access_token(self._access_token, self._access_token_secret)
self._stream = ExStream(auth, listener)
return self._stream
def get_oauth():
inifile = ConfigParser.SafeConfigParser()
inifile.read("config.ini")
consumer_key = inifile.get("CONSUMER", "KEY")
consumer_secret = inifile.get("CONSUMER", "SECRET")
access_key = inifile.get("ACCESS","KEY")
access_secret = inifile.get("ACCESS","SECRET")
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
return auth
def build_stream(self):
if self.stream != None:
self.stop_query()
time.sleep(.01) # make sure old stream has time to disconnect
oauth = OAuthHandler(self.consumer_key, self.consumer_secret)
oauth.set_access_token(self.access_token, self.access_token_secret)
self.stream = Stream(oauth, # do OAuthentication for stream
self, # this object implements StreamListener
timeout = 600, # reconnect if no messages in 600s
retry_count = 20, # try reconnecting 20 times
retry_time = 10.0, # wait 10s if no HTTP 200
snooze_time = 1.0) # wait 1s if timeout in 600s
class NewsMeDigestTweeter(object):
def __init__(self,debug=True):
self._oauth = None
self._oauth_api = None
self._oauth_init()
self._debug = debug
self.tweet_counter = 0
self._model_queries = NewsMeModelQueries()
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 follow_digestion_user(self,digestion_user):
pass
#try:
# if self._oauth_api.exists_friendship(digestion_user, 'twixmit') == False:
# friend = self._oauth_api.create_friendship(digestion_user)
#except TweepError, e:
# logging.error("TweepError: %s", e)
#logging.info("following: %s" % digestion_user)
def tweet_from_digestion(self,digest_articles, digestion_user):
for k, v in digest_articles.iteritems():
status_text = "%s %s" % (v,k)
model_check = self._model_queries.check_model_for_tweet(digestion_user,k)
logging.info("model check for user and link is %s" % model_check)
if not self._debug and not model_check:
try:
self._oauth_api.update_status(status=status_text,source="twixmit")
self.tweet_counter = self.tweet_counter + 1
except TweepError, e:
logging.error("TweepError: %s", e)
if not model_check:
self.save_tweet_to_model(digestion_user,k,v)
else:
logging.warn("link was already tweeted: %s" % k)
class StreamsTestsPlain(object):
def __init__(self):
self._stream = None
self._oauth = None
self._oauth_api = None
self._stream_init()
self._oauth_init()
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 _stream_init(self):
api1 = API()
headers = {}
headers["Accept-Encoding"] = "deflate, gzip"
stream_auth = BasicAuthHandler(social_keys.TWITTER_HTTP_AUTH_U,social_keys.TWITTER_HTTP_AUTH_P)
l = TestStreamListener(api=api1)
self._stream = Stream(auth=stream_auth,listener=l,secure=True,headers=headers)
def sample(self):
self._stream.sample()
def filter_follow(self):
follow_names = ['hnfirehose','StockTwits','YahooFinance','Street_Insider','TheStreet','SquawkCNBC','CNBC','AP_PersonalFin','themotleyfool','MarketWatch','Reuters_Biz']
follow_usr_objs = self._oauth_api.lookup_users(screen_names=follow_names)
follow_ids = []
for follow_usr in follow_usr_objs:
follow_ids.append(follow_usr.id)
print follow_ids
self._stream.filter(follow=follow_ids)
def filter(self):
self._stream.filter(track=["@newsdotme","@twixmit","@app_engine"])
