def _get_twitter_access(self, username):
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
url = auth.get_authorization_url()
print 'Go here: %s and enter the corresponding PIN' % url
pin = raw_input('PIN:')
auth.get_access_token(pin)
return (auth.access_token.key, auth.access_token.secret)
class SanchanOAuthHandler():
def __init__(self, config):
self.config = config
self.keys = self.config.OAuthKeys()
self.oauth = OAuthHandler(self.keys['consumer_key'],
self.keys['consumer_secret'],
secure = True
)
self.oauth.set_access_token(self.keys['access_token_key'], self.keys['access_token_secret'])
def authenticate(self):
return self.oauth
def request(self):
print "Authorize this app via this URL: "
print self.oauth.get_authorization_url()
pincode = raw_input('Then, input the proposed PIN: ')
try:
self.oauth.get_access_token(verifier=pincode)
except error.TweepError, e:
print e
print "[EMERG] Authentication error!"
sys.exit(1)
print "Put these access keys into your config.yml:"
print "access_token: " + self.oauth.access_token.key
print "access_token_secret: " + self.oauth.access_token.secret
sys.exit(0)
class Twit(object):
def __init__(self,consumer_token, access_token=None):
if not isinstance(consumer_token, Token): raise Exception("consumer_token is invalid type!")
self.auth = OAuthHandler(consumer_token.key, consumer_token.secret)
self.api = None
if access_token != None and isinstance(access_token, Token):
# ok
self.auth.set_access_token(access_token.key, access_token.secret)
self.api = self._get_api(self.auth)
def _get_api(self, auth):
return API(auth,retry_count=3,cache=tweepy.MemoryCache(timeout=60))
def get_auth_url(self):
return self.auth.get_authorization_url()
def get_access_token(self, pin):
self.auth.get_access_token(pin)
self.api = self._get_api(self.auth)
return Token(self.auth.access_token.key, self.auth.access_token.secret)
@classmethod
def get_msg_length(cls, msg):
"""
https://dev.twitter.com/docs/api/1.1/get/help/configuration
"""
msg = re.sub(RegexHttpUrl, "0123456789012345678901", msg)
msg = re.sub(RegexHttpsUrl, "01234567890123456789012", msg)
return len(msg)
@classmethod
def validate_msg(cls, msg):
"""
Args:
msg: str, 投稿するメッセージ
Return:
(is_valid:bool, reminder:int)
"""
max_msg_length = 140
is_valid = False
msg_length = cls.get_msg_length(msg)
reminder = 140 - msg_length
if 0 < msg_length <= max_msg_length: is_valid = True
return (is_valid, reminder)
def post(self, msg):
return self.api.update_status(status=msg)
def verify_credentials(self, include_entities=True, skip_status=False):
return self.api.verify_credentials(include_entities=include_entities, skip_status=skip_status)
def get_user_timeline(self, screen_name, count=50):
return self.api.user_timeline(screen_name=screen_name, count=count)
def destroy_status(self, status_id):
return self.api.destroy_status(id=status_id)
class WTweetUser:
def __init__(self):
_CONSUMER_KEY = '9o4scrLHTFt7NzyVxD5Q'
_CONSUMER_SECRET = 'xlrPmai1QgNTRQTf86inp1bzEFLgEXD7XuN5ZENKAU'
self.__auth_handler = OAuthHandler(_CONSUMER_KEY, _CONSUMER_SECRET)
self.__access_token = None
def set_access_token(self, access_token):
self.__access_token = self.__auth_handler.set_access_token(key=access_token['key'], secret=access_token['secret'])
def get_auth_handler(self):
return self.__auth_handler
def logout(self):
with loadfile('w') as f:
f.truncate()
f.close()
print 'logout successful!'
def login(self):
try:
auth_url = self.__auth_handler.get_authorization_url()
print 'give me a pin code from url: {0}'.format(auth_url)
verifier = raw_input('enter a pin code: ').strip()
self.__auth_handler.get_access_token(verifier=verifier)
access_token = { 'key': self.__auth_handler.access_token.key, 'secret': self.__auth_handler.access_token.secret }
with loadfile('w+') as f:
f.truncate()
f.write(JSONEncoder().encode(access_token))
f.close()
except TweepError as err:
print err.__str__()
return WTweetTimeline(self)
def is_login(self):
with loadfile('r') as f:
cfg = f.readline()
f.close()
access_token = JSONDecoder().decode(cfg)
if 'key' in access_token and 'secret' in access_token:
self.set_access_token(access_token=access_token)
return True
else:
return False
def get_timeline(self):
with loadfile('r') as f:
cfg = f.readline()
f.close()
self.set_access_token(JSONDecoder().decode(cfg))
return WTweetTimeline(self)
def run():
print 'Input your application info.'
consumer_key = raw_input('Consumer Key: ')
consumer_secret = raw_input('Consumer Secret: ')
auth = OAuthHandler(consumer_key,
consumer_secret)
print "Visit the following url and allow TweetHandler to access."
print '>>> %s' % auth.get_authorization_url()
print ''
vcode = raw_input('Enter verification code: ')
token = auth.get_access_token(vcode)
print 'OK. You can setup TweetHander with following code.'
print """ ----
from tweethandler import TweetHandler
import logging
th = TweetHandler('%s',
'%s',
'%s',
'%s')
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
th.setLevel(logging.DEBUG)
logger.addHandler(th)
logger.info('Your log message')
""" % (consumer_key, consumer_secret,
token.key, token.secret)
def accessToken(self): if self.session.access_token: # return the token (TODO: does it expire?) auth = OAuthHandler(self.client_id, self.client_secret); auth.set_access_token( self.session.access_token.key , self.session.access_token.secret) return auth if self.session.request_token: # Exchange the request token with an authorization token. token = self.session.request_token self.session.request_token = None auth = OAuthHandler( self.client_id, self.client_secret ) auth.set_request_token(token.key, token.secret) try: self.session.access_token = auth.get_access_token(self.request.vars.oauth_verifier) except tweepy.TweepError: print 'Error! Failed to get access token.' print self.session.access_token return auth return None
def callback(request):
"""
Receive the Oauth token back from Twitter
"""
verifier = request.GET.get('oauth_verifier')
if verifier is None:
response = HttpResponseRedirect(reverse('experiment_main'))
return response
oauth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
token = request.session.get('unauthed_token_twitterexp', None)
if token is None:
request.session['auth_error'] = True
return HttpResponseRedirect(ROOT_URL)
request.session['auth_error'] = False
# remove the request token now we don't need it
request.session.delete('unauthed_token_twitterexp')
oauth.set_request_token(token[0], token[1])
# get the access token and store
try:
oauth.get_access_token(verifier)
except TweepError:
print 'Error, failed to get access token'
request.session['auth_error'] = True
return HttpResponseRedirect(ROOT_URL)
request.session['access_key_twitterexp'] = oauth.access_token.key
request.session['access_secret_twitterexp'] = oauth.access_token.secret
api = get_api(request)
twitter_user = api.me()
twitter_user = add_or_update_twitter_user(twitter_user)
experiment_user, user = get_or_add_user(twitter_user)
user.set_password('')
user = authenticate(username=twitter_user.twitter_id, password='')
login(request, user)
response = HttpResponseRedirect(reverse('experiment_start'))
return response
def get_auth():
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
if not os.path.exists(CREDENTIALS_FILE):
authorization_url = auth.get_authorization_url()
webbrowser.open_new(authorization_url)
pin = input('PIN: ')
auth.get_access_token(pin)
cred = {
'ACCESS_TOKEN': auth.access_token,
'ACCESS_SECRET': auth.access_token_secret
}
fp = open(CREDENTIALS_FILE, 'wb')
pickle.dump(cred, fp)
fp.close()
else:
fp = open(CREDENTIALS_FILE, 'rb')
cred = pickle.load(fp)
fp.close()
auth.set_access_token(cred['ACCESS_TOKEN'], cred['ACCESS_SECRET'])
return auth
def do_report(request_token, oauth_verifier, accounts, block=False):
logger = logging.getLogger(__name__)
if not logger.hasHandlers():
logger.addHandler(logging.StreamHandler())
logger.setLevel(logging.INFO)
output = ''
try:
twitter_auth = OAuthHandler(settings.CONSUMER_KEY,
settings.CONSUMER_SECRET)
twitter_auth.request_token = {
'oauth_token': request_token,
'oauth_token_secret': oauth_verifier
}
twitter_auth.get_access_token(oauth_verifier)
twitter_api = API(twitter_auth,
wait_on_rate_limit=True,
wait_on_rate_limit_notify=True,
retry_count=0,
timeout=5)
for account_name, account_type in accounts.items():
output += 'Reporting: ' + account_name + '\n'
try:
if account_type == 'user_id':
user = twitter_api.report_spam(user_id=account_name,
perform_block=block)
else:
user = twitter_api.report_spam(screen_name=account_name,
perform_block=block)
output += 'Reported: https://twitter.com/' + user.screen_name + '\n'
logger.info('Reported: https://twitter.com/' +
user.screen_name)
except TweepError as e:
if e.api_code == 34: # Account does not exist, skip
output += e.reason + '\n'
else:
raise e
except TweepError as e:
output += e.reason + '\n'
output += 'Done(' + str(datetime.now()) + ')'
return escape(output)
def twitter_oauth_verify(request):
redirect_url = reverse('landing')
request_token_key = request.session.pop('request_token_key', '')
request_token_secret = request.session.pop('request_token_secret', '')
handler = OAuthHandler(settings.CONSUMER_KEY, settings.CONSUMER_SECRET)
handler.set_request_token(request_token_key, request_token_secret)
verifier = request.GET.get('oauth_verifier', '')
try:
handler.get_access_token(verifier)
except TweepError:
pass
else:
user = authenticate(access_token_key=handler.access_token.key, access_token_secret=handler.access_token.secret, consumer_key=settings.CONSUMER_KEY, consumer_secret=settings.CONSUMER_SECRET)
login(request, user)
redirect_url = request.session.pop('next', redirect_url)
return redirect(redirect_url)
def doOAuthDance(consumer_key, consumer_secret):
# If we already have an access token saved, just use that
if os.path.exists(ACCESS_TOKEN_PATH):
accessFile = open(ACCESS_TOKEN_PATH, 'r')
access_token_key = accessFile.readline().strip()
access_token_secret = accessFile.readline().strip()
accessFile.close()
auth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token_key, access_token_secret)
return auth
auth = OAuthHandler(consumer_key, consumer_secret)
try:
redirect_url = auth.get_authorization_url()
except TweepError:
print ('Error! Failed to get request token.')
return None
print(('Get PIN from: %s' % (redirect_url)))
webbrowser.open(redirect_url)
verifier = input('Input Twitter verifier PIN:')
try:
auth.get_access_token(verifier)
except:
print ('Error! Failed to get access token.')
return None
# Save the access token for later use
accessFile = open(ACCESS_TOKEN_PATH, 'wt')
accessFile.write('%s\n%s' % (auth.access_token.key, auth.access_token.secret))
accessFile.close()
return auth
def testoauth(self):
auth = OAuthHandler(oauth_consumer_key, oauth_consumer_secret)
# test getting access token
auth_url = auth.get_authorization_url()
print('Please authorize: ' + auth_url)
verifier = raw_input('PIN: ').strip()
self.assert_(len(verifier) > 0)
access_token = auth.get_access_token(verifier)
self.assert_(access_token is not None)
# build api object test using oauth
api = API(auth)
s = api.update_status('test %i' % random.randint(0, 1000))
api.destroy_status(s.id)
def testoauth(self):
auth = OAuthHandler(oauth_consumer_key, oauth_consumer_secret)
# test getting access token
auth_url = auth.get_authorization_url()
print('Please authorize: ' + auth_url)
verifier = raw_input('PIN: ').strip()
self.assert_(len(verifier) > 0)
access_token = auth.get_access_token(verifier)
self.assert_(access_token is not None)
# build api object test using oauth
api = API(auth)
s = api.update_status('test %i' % random.randint(0, 1000))
api.destroy_status(s.id)
def get_auth_link_and_show_token():
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.secure = True
auth_url = auth.get_authorization_url()
input(
"Log in to https://twitter.com as the user you want to tweet as and hit enter."
)
input("Visit %s in your browser and hit enter." % auth_url)
pin = input("What is your PIN: ")
token = auth.get_access_token(verifier=pin)
print(
"\nThese are your access token and secret.\nDO NOT SHARE THEM WITH ANYONE!\n"
)
print("ACCESS_TOKEN\n%s\n" % token[0])
print("ACCESS_TOKEN_SECRET\n%s\n" % token[1])
def setup():
'''This function gives you all the keys for the Twitter-API.
Look in the text below to costume it with your app. Or only run it to get
all keys for the socialpy gateway.
The app-token are from my test app. I'm not shore if it's a god idea to let
them now you. But so you can easily run this scrip and have all the keys you
need for my gateway.'''
# create your SocialPy folder if it not exists
check(create=True)
# Go to https://dev.twitter.com and sign up for a developer account. Then
# create an app. This app shouldn’t have a callback url. Look in your app
# for the tokens and use them for the OAuthHandler
consumer_token = 'kYdbvAGXIhWGHyNKdNTssfpzE'
consumer_secret = 'MM2EVucINNxfFEB0akTenqConUnucj9FaS4hMX1F7wEw5WDvD1'
auth = OAuthHandler(consumer_token, consumer_secret)
# This will open your web browser and ask you to verify for the app. If you
# agree, they show you a pin. If your app has a callback url, they would
# redirect you to this url and didn't show you the pin.
try:
redirect_url = webbrowser.open(auth.get_authorization_url())
time.sleep(1)
except TweepError:
print('Error! Failed to get request token.')
exit()
pin = input('\nVerification pin number from twitter.com: ').strip()
token = auth.get_access_token(verifier=pin)
print('All the token:')
print('ckey:', consumer_token)
print('csecret:', consumer_secret)
print('akey:', auth.access_token)
print('asecret:', auth.access_token_secret)
# create the Gateway and save the keys
gateway = Gateway(keyfile=SOCIALPY_KEY_FILE)
gateway['twitter'].setup(ckey=consumer_token,
csecret=consumer_secret,
akey=auth.access_token,
asecret=auth.access_token_secret)
gateway.save_to_file(SOCIALPY_KEY_FILE)
print('save the keys in your SocialPy file')
def testoauth(self):
if not consumer_key or not consumer_secret:
self.skipTest("Missing consumer key and/or secret")
auth = OAuthHandler(consumer_key, consumer_secret)
# test getting access token
auth_url = auth.get_authorization_url()
print('Please authorize: ' + auth_url)
verifier = input('PIN: ').strip()
self.assertTrue(len(verifier) > 0)
access_token = auth.get_access_token(verifier)
self.assertTrue(access_token is not None)
# build api object test using oauth
api = API(auth)
s = api.update_status(f'test {random.randint(0, 1000)}')
api.destroy_status(s.id)
def twitter_callback(request):
"""
Twitterからのコールバック時に呼び出される。
:param request: リクエストオブジェクト
:type request: django.http.HttpRequest
:return: 遷移先を示すレスポンスオブジェクト
:rtype: django.http.HttpResponse
"""
# セッションからリクエストトークンを取得する
request_token = request.session.get('request_token')
if not request_token:
request.session.clear()
return HttpResponse('Unauthorized', status=401)
# Twitterからの返却値を取得する
oauth_token = request.GET.get('oauth_token')
oauth_verifier = request.GET.get('oauth_verifier')
# セッションの値とTwitterからの返却値が一致しない場合は処理を中断する
if request_token.get('oauth_token') != oauth_token:
request.session.clear()
return HttpResponse('Unauthorized', status=401)
# アクセストークンを取得する
oauth_handler = OAuthHandler(settings.CONSUMER_KEY, settings.CONSUMER_SECRET)
oauth_handler.request_token = request_token
access_token = oauth_handler.get_access_token(oauth_verifier)
# 認証処理を実行する
authenticated_user = authenticate(access_token=access_token)
if authenticated_user:
login(request, authenticated_user)
else:
request.session.clear()
return HttpResponse('Unauthorized', status=401)
# ログイン後に遷移すべき画面にリダイレクトする
url = request.session.get('next', getattr(settings, 'AFTER_LOGIN_URL', '/'))
return HttpResponseRedirect(url)
def get_token():
# Get authorization information from secure file
with open("etc/auth/auth.txt", "r") as authFile:
consumerKey = authFile.readline().strip()
consumerSecret = authFile.readline().strip()
# Authenticate the twitter consumer key
twitter_auth = OAuthHandler(consumerKey, consumerSecret)
twitter_auth.secure = True
authUrl = twitter_auth.get_authorization_url()
# go to this URL to authorize
print("PLase visit this link and authorize the app ==> " + authUrl)
print ("Enter the Authorization PIN")
# Write the access tokens to file
pin = input().strip() # strip the new line character from pressing 'enter'
token = twitter_auth.get_access_token(verifier=pin)
with open("etc/auth/tokens.txt", "w") as accessTokenFile:
accessTokenFile.write(token[0]+'\n') # '\n' indicates a newline char
accessTokenFile.write(token[1]+'\n')
return
def login1(request):
try:
request_token1 = session['request_token']
del session['request_token']
auth = OAuthHandler(ak, aks)
auth.request_token = request_token1
verifier = request.GET.get('oauth_verifier')
if verifier is None: return render(request, 'invalid.html', {})
auth.get_access_token(verifier)
key, secret = auth.access_token, auth.access_token_secret
auth.set_access_token(key, secret)
twitter_client = API(auth, wait_on_rate_limit=True)
tweets_id = []
tweets_user = {}
tweets_url_count = {}
now = datetime.now()
for tweet in twitter_client.home_timeline():
if now < (tweet.created_at - timedelta(hours=(24 * 7))): break
if tweet.entities['urls'] != []:
#*************** entering into database**********
try:
obj = TweetsDetails()
obj.created_at = str(tweet.created_at)[:19]
obj.tweet_id = tweet.id
obj.tweet_by = tweet.user.screen_name
obj.user_twitter_id = myself.screen_name
unique_str = myself.screen_name + str(tweet.id)
obj.unique = unique_str
obj.save()
except:
l = 0
l = len(tweet.entities['urls'])
if str(tweet.user.screen_name) in tweets_user:
tweets_user[str(tweet.user.screen_name)] += l
else:
tweets_user[str(tweet.user.screen_name)] = l
for i in range(l):
if tweet.entities['urls'][i]['url'] in tweets_url_count:
tweets_url_count[tweet.entities['urls'][i]['url']] += 1
else:
tweets_url_count[tweet.entities['urls'][i]['url']] = 1
tweets_id.append(int(tweet.id))
top_url_counts, top_active_users, embed_links = [], [], []
for x in tweets_url_count.keys():
top_url_counts.append([tweets_url_count[x], x])
for x in tweets_user:
top_active_users.append([tweets_user[x], x])
for id in tweets_id:
embReqUrl = 'https://publish.twitter.com/oembed?url=https%3A%2F%2Ftwitter.com%2FInterior%2Fstatus%2F' + str(
id)
embResp = requests.get(embReqUrl).json()
embed_links.append(embResp['html'])
top_active_users.sort(reverse=True)
top_url_counts.sort(reverse=True)
if len(top_active_users) > 3: top_active_users = top_active_users[:3]
if len(top_url_counts) > 3: top_url_counts = top_url_counts[:3]
if len(top_active_users) == 0: top_active_users.append(['-', '-'])
if len(top_url_counts) == 0: top_url_counts.append(['-', '-'])
x = []
#Modifying tweet embed link as a string
s = ' tw-align-center'
for i in range(len(embed_links)):
embed_links[i] = embed_links[i][:len(embed_links[i]) - 86]
embed_links[i] = embed_links[i][:32] + s + embed_links[i][32:]
x.append(embed_links[i])
finaldict = {}
finaldict['embedlink'] = x
finaldict['urlcount'] = top_url_counts
finaldict['topuser'] = top_active_users
return render(request, 'second page.html', finaldict)
except Exception as e:
print(e)
return render(request, 'invalid.html', {})
import tweepy
import json
from tweepy import AppAuthHandler
from tweepy import OAuthHandler
with open("private/oauth-config.json", "r") as config:
oauth_config = (json.loads(config.read()))
consumer_key = oauth_config.get('consumer-key')
consumer_secret = oauth_config.get('consumer-secret')
oauth = OAuthHandler(consumer_key, consumer_secret)
try:
redirect_url = oauth.get_authorization_url()
except tweepy.TweepError:
print('Error: failed to get the redirect URL.')
access_token = oauth.get_access_token(verifier='enter pin here')
from tweepy import OAuthHandler
CONSUMER_KEY = 'place key here'
CONSUMER_SECRET = 'place secret here'
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth_url = auth.get_authorization_url()
print('Please authorize: ' + auth_url)
verifier = input('PIN: ').strip()
auth.get_access_token(verifier)
print("ACCESS_KEY = '%s'" % auth.access_token.key)
print("ACCESS_SECRET = '%s'" % auth.access_token.secret)
from tweepy import OAuthHandler
from tweepy import TweepError
from config import get_config
from log_handler import get_logger
logger = get_logger(__name__)
CONSUMER_KEY = get_config().consumer_key
CONSUMER_SECRET = get_config().consumer_secret
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
try:
redirect_url = auth.get_authorization_url()
print(f"Go here, get the code => {redirect_url}")
verification_code = input("Verification Code: ")
auth.request_token.update({"oauth_token_secret": verification_code})
auth.get_access_token(verification_code)
print("---")
print(f"Access Token => {auth.access_token}")
print(f"Secret Token => {auth.access_token_secret}")
print("---")
except TweepError as e:
print("Unable to continue...")
logger.error(e)
them now you. But so you can easily run this scrip and have all the keys you
need for my gateway.
'''
from tweepy import OAuthHandler, API, TweepError
import webbrowser
# Go to https://dev.twitter.com and sign up for a developer account. Then create
# an app. This app shouldn’t have a callback url. Look in your app for the
# tokens and use them for the OAuthHandler
consumer_token = 'kYdbvAGXIhWGHyNKdNTssfpzE'
consumer_secret = 'MM2EVucINNxfFEB0akTenqConUnucj9FaS4hMX1F7wEw5WDvD1'
auth = OAuthHandler(consumer_token, consumer_secret)
# This will open your web browser and ask you to verify for the app. If you
# agree, they show you a pin. If your app has a callback url, they would
# redirect you to this url and didn't show you the pin.
try:
redirect_url = webbrowser.open(auth.get_authorization_url())
except TweepError:
print('Error! Failed to get request token.')
exit()
pin = input('Verification pin number from twitter.com: ').strip()
token = auth.get_access_token(verifier=pin)
print('All the token:')
print('ckey:', consumer_token)
print('csecret:', consumer_secret)
print('akey:', auth.access_token)
print('asecret:', auth.access_token_secret)
