def __init__(self, data_file, client_id, client_secret, from_address,
header, footer):
Source.__init__(self, data_file)
self.consumer = Consumer(client_id, client_secret)
self.from_address = from_address
self.header = header
self.footer = footer
self.access_token = None
def getCert(self, id, cfg, token, verifier):
oauthKey = cfg[OAUTH_CONSUMER_KEY]
params = {
'oauth_nonce': generate_nonce(),
'oauth_token': token,
'oauth_verifier': verifier,
'oauth_timestamp': generate_timestamp(),
'oauth_signature_method': 'RSA-SHA1',
'oauth_consumer_key': oauthKey,
'oauth_version': '1.0'
}
consumer = Consumer(oauthKey, '')
rsa_sha1 = SignatureMethod_RSA_SHA1(
privateKeyFile=cfg[PRIVATE_KEY_FILE_TAG])
client = OA4MPClient(consumer=consumer)
client.set_signature_method(rsa_sha1)
response, content = client.request(cfg[SERVICE_URI_TAG] + '/token',
parameters=params)
tokens = content.split('&')
access_token = urllib.unquote(tokens[0].split('=')[1])
params = {
'oauth_nonce': generate_nonce(),
'oauth_token': access_token,
'oauth_timestamp': generate_timestamp(),
'oauth_signature_method': 'RSA-SHA1',
'oauth_consumer_key': oauthKey,
'oauth_version': '1.0'
}
# we now have the token and the secret.
consumer = Consumer(oauthKey, '')
rsa_sha1 = SignatureMethod_RSA_SHA1(
privateKeyFile=cfg[PRIVATE_KEY_FILE_TAG])
client = OA4MPClient(consumer=consumer)
client.set_signature_method(rsa_sha1)
response, content = client.request(cfg[SERVICE_URI_TAG] + '/getcert',
parameters=params)
tokens = content.split('\n')
username = urllib.unquote(tokens[0].split('=')[1])
tokens = tokens[1:]
certs = '\n'.join(tokens)
fileStore = FileStore(cfg)
asset = fileStore.get(id)
asset[USERNAME_KEY] = username
asset[CERTS_KEY] = certs
fileStore.put(id, asset)
return username, certs
def request(self, url, method="GET", params={}, body='', headers=''):
if not self.consumer_key or not self.consumer_secret or not self.access_token or not self.access_token_secret:
message = "BaseOAuth: Required parameters not provided."
logger.error(message)
raise Exception(message)
consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret)
token = Token(key=self.access_token, secret=self.access_token_secret)
client = Client(consumer, token)
_url = url
if url[-1] != '?':
_url += '?'
_url += '&'.join(
map(lambda x: "{}={}".format(x, params[x]), params.keys()))
url = _url
logger.info("{}: {}, Body: {}, Headers: {}".format(
method, url, body, headers))
resp, content = client.request(url,
method=method,
body=body,
headers=headers)
return content
def __init__(self,
api_key: str,
api_secret: str,
base_url: str = "https://www.plurk.com"):
self.consumer = Consumer(api_key, api_secret) # type:Consumer
self.client = Client(self.consumer) # type:Client
self.base_url = base_url # type:str
def authenticate(self, key, secret):
consumer = Consumer(settings.TWITTER_CONSUMER_KEY, settings.TWITTER_CONSUMER_SECRET)
token = Token(key, secret)
client = Client(consumer, token)
response, content = client.request(twitter_auth_settings.ACCESS_TOKEN_URL, "GET")
if not response.get('status') == '200':
raise TwitterAuthException("Invalid response from Twitter.", response)
access_token = dict(cgi.parse_qsl(content))
# if we have an access token, it means we have authenticated with Twitter
user, created = User.objects.get_or_create(username=access_token['screen_name'])
if created:
twitter_user_created.send(
sender="TwitterAuth",
user=user,
screen_name=access_token['screen_name'],
user_id=access_token['user_id']
)
# give the user a temporary password - it should never be needed since
# Twitter is providing the authentication token.
user.set_password(User.objects.make_random_password(length=12))
user.save()
# update credentials
user.twitterauth.oauth_token = access_token.get('oauth_token')
user.twitterauth.oauth_secret = access_token.get('oauth_token_secret')
user.twitterauth.save()
twitter_user_authenticated.send(sender='TwitterAuth', user=user)
return user
def main(args):
conf = configparser.SafeConfigParser()
try:
conf.read(args.configfile)
consumer_key = conf.get('general', 'consumer_key')
consumer_secret = conf.get('general', 'consumer_secret')
user_key = conf.get('general', 'user_key')
user_secret = conf.get('general', 'user_secret')
except Exception as e:
print('err: (', args.configfile, ')', e, file=sys.stderr)
sys.exit(1)
twclient = Client(
Consumer(consumer_key, consumer_secret),
Token(user_key, user_secret),
)
if args.replyid is None:
ret = twclient.request(
'https://api.twitter.com/1.1/statuses/update.json', 'POST',
urlencode({'status': args.message}))
else:
ret = twclient.request(
'https://api.twitter.com/1.1/statuses/update.json', 'POST',
urlencode({
'status': args.message,
'in_reply_to_status_id': args.replyid
}))
if int(ret[0]['status']) == 200:
print(ret[1].decode('utf-8'))
else:
print('err:', ret[0]['status'], file=sys.stderr)
print(ret[1].decode('utf-8'))
sys.exit(2)
def do(config, token=None, sec=None, verifier=None):
consumer = Consumer(config['consumer_key'], config['consumer_sec'])
client = Client(consumer)
response, content = client.request(REQUEST_TOKEN_URL, 'GET')
request_token = dict(urlparse.parse_qsl(content))
print request_token['oauth_token']
print request_token['oauth_token_secret']
print '%s?oauth_token=%s' % (AUTHORIZE_URL, request_token['oauth_token'])
def get_access_token(config, token, sec, verifier):
consumer = Consumer(config['consumer_key'], config['consumer_sec'])
token = Token(token, sec)
token.set_verifier(verifier)
client = Client(consumer, token)
response, content = client.request(ACCESS_TOKEN_URL)
access_token = dict(urlparse.parse_qsl(content))
print access_token
def __init__(self, server, request_token_url,
access_token_url, authorization_url,
consumer_key, consumer_secret):
self.server = server
self.request_token_url = request_token_url
self.access_token_url = access_token_url
self.authorization_url = authorization_url
self.consumer = Consumer(consumer_key, consumer_secret)
self.connection = httplib.HTTPSConnection(str(self.server))
class Google(Source):
def __init__(self, data_file, client_id, client_secret, from_address,
header, footer):
Source.__init__(self, data_file)
self.consumer = Consumer(client_id, client_secret)
self.from_address = from_address
self.header = header
self.footer = footer
self.access_token = None
def setUp(self):
try:
refresh_token = self._read_from_file('google')
except (IOError, ValueError, KeyError):
refresh_token = None
if not refresh_token:
print self.consumer.authorize(
AUTH_URL,
'code',
redirect_uri='urn:ietf:wg:oauth:2.0:oob',
scope='%20'.join([
'https://mail.google.com/',
'https://www.googleapis.com/auth/gmail.modify',
'https://www.googleapis.com/auth/gmail.compose'
]),
login_hint=self.from_address)
refresh_token = self.consumer.get_request_token(
TOKEN_URL,
'authorization_code',
code=raw_input(
'Please enter the code provided by the website: '),
redirect_uri='urn:ietf:wg:oauth:2.0:oob')
self._write_to_file('google', refresh_token)
self.access_token = self.consumer.get_access_token(
TOKEN_URL, refresh_token)
def send_message(self, message, to_address):
msg = MIMEText(self.header + message + self.footer)
msg['To'] = to_address
msg['From'] = self.from_address
raw = base64.urlsafe_b64encode(msg.as_string())
return self.consumer.api_request_post(SEND_URL,
self.access_token,
raw=raw)
def __init__(self,
api_key: str,
api_secret: str,
token_key: str,
token_secret: str,
base_url: str = "https://www.plurk.com"):
consumer = Consumer(api_key, api_secret) # type:Consumer
token = Token(token_key, token_secret) # type:Token
self.client = Client(consumer, token) # type:Client
self.base_url = base_url # type:str
def __init__(self, ckey, csec, ukey, usec, use_cache=True):
self.client = Client(Consumer(ckey, csec), Token(ukey, usec))
self.client.to_url = self._override_tourl
try:
f = open(self.fnCache, 'rb')
except IOError:
print("no cache file")
self._write_Cache()
else:
self.objCache = pickle.load(f)
class Imgur(Source):
def __init__(self, data_file, client_id, client_secret):
Source.__init__(self, data_file)
self.consumer = Consumer(client_id, client_secret)
self.access_token = None
def setUp(self):
try:
refresh_token = self._read_from_file('imgur')
except (IOError, ValueError, KeyError):
refresh_token = None
if not refresh_token:
print self.consumer.authorize(AUTH_URL, 'pin')
refresh_token = self.consumer.get_request_token(
TOKEN_URL, 'pin', pin=raw_input('Please enter the pin: '))
self._write_to_file('imgur', refresh_token)
self.access_token = self.consumer.get_access_token(
TOKEN_URL, refresh_token)
def get_message(self, album_name):
albums = self.consumer.api_request_get(ALBUMS_URL,
self.access_token)['data']
album_id = None
for album in albums:
if album['title'] == album_name:
album_id = album['id']
images = self.consumer.api_request_get(
ALBUM_URL + album_id, self.access_token)['data']['images']
links = [image['link'] for image in images]
return random.sample(links, 1)[0]
def doSetup(self):
print 'Running twitter setup...'
consumer = Consumer(self.consumer_key, self.consumer_secret)
print consumer
client = Client(consumer)
resp, content = client.request(TWITTER_REQUEST_TOKEN_URL, "GET")
if resp['status'] != '200':
raise Exception("Invalid response %s." % resp['status'])
self.request_token = dict(urlparse(content))
print "Request Token:"
print " - oauth_token = %s" % self.request_token[
'oauth_token']
print " - oauth_token_secret = %s" % self.request_token[
'oauth_token_secret']
print
# Step 2: Redirect to the provider. Since this is a CLI script we do not
# redirect. In a web application you would redirect the user to the URL
# below.
print "Go to the following link in your browser:"
print "%s?oauth_token=%s" % (TWITTER_AUTHORIZE_URL,
self.request_token['oauth_token'])
print
# After the user has granted access to you, the consumer, the provider will
# redirect you to whatever URL you have told them to redirect to. You can
# usually define this in the oauth_callback argument as well.
accepted = 'n'
while accepted.lower() == 'n':
accepted = raw_input('Have you authorized me? (y/n) ')
oauth_verifier = raw_input('What is the PIN? ')
# Step 3: Once the consumer has redirected the user back to the oauth_callback
# URL you can request the access token the user has approved. You use the
# request token to sign this request. After this is done you throw away the
# request token and use the access token returned. You should store this
# access token somewhere safe, like a database, for future use.
token = Token(self.request_token['oauth_token'],
self.request_token['oauth_token_secret'])
token.set_verifier(oauth_verifier)
client = Client(consumer, token)
resp, content = client.request(TWITTER_ACCESS_TOKEN_URL, "POST")
self.access_token = dict(urlparse(content))
print "Access Token:"
print " - oauth_token = %s" % self.access_token['oauth_token']
print " - oauth_token_secret = %s" % self.access_token[
'oauth_token_secret']
print
print "You may now access protected resources using the access tokens above."
def _get_auth_headers(self, method, url):
oauth_params = {
'oauth_version': "1.0",
'oauth_nonce': generate_nonce(),
'oauth_timestamp': int(time.time())
}
oauth_request = OAuthRequest(method, url, parameters=oauth_params)
consumer = Consumer(self.client, self.oauth_secret)
oauth_request.sign_request(SignatureMethod_HMAC_SHA1(), consumer, None)
auth_headers = oauth_request.to_header()
auth_headers['Authorization'] = auth_headers['Authorization'].encode(
'utf-8')
return auth_headers
def __init__(self, customer_key=None, customer_secret=None):
self.base_url = 'https://www.plurk.com'
self.request_token_url = '/OAuth/request_token'
self.authorization_url = '/OAuth/authorize'
self.access_token_url = '/OAuth/access_token'
self.customer_key = customer_key
self.customer_secret = customer_secret
self.sign_method = SignatureMethod_HMAC_SHA1()
self.consumer = None
self.token = None
self.oauth_token = {}
if self.customer_key and self.customer_secret:
self.consumer = Consumer(self.customer_key, self.customer_secret)
def __init__(self, consumer_key, consumer_secret, token_key, token_secret):
consumer = Consumer(key=consumer_key, secret=consumer_secret)
token = Token(key=token_key, secret=token_secret)
proxy_info = None
if hasattr(settings, 'PROXY_HOST') and \
hasattr(settings, 'PROXY_PORT'):
proxy_info = ProxyInfo(proxy_type=PROXY_TYPE_HTTP,
proxy_host=settings.PROXY_HOST,
proxy_port=settings.PROXY_PORT)
self.client = Client(consumer=consumer,
token=token,
proxy_info=proxy_info)
def SendMsg(self, update):
token = Token(key=self.access_key, secret=self.access_secret)
consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret)
client = Client(consumer, token)
request_uri = 'https://api.twitter.com/1/statuses/update.json'
data = {
u'status':
unicodedata.normalize('NFKD',
update[:140]).encode('ASCII', 'ignore')
}
resp = client.request(request_uri, 'POST', urllib.urlencode(data))[0]
print resp.content
print resp.status
def oauth_request(self,
url,
key,
secret,
http_method="GET",
http_headers=None):
consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret)
token = Token(key=key, secret=secret)
client = Client(consumer, token)
resp, content = client.request(url,
method=http_method,
headers=http_headers)
return content
def invoke(self, controller, selection):
target = selection[0]
consumer = Consumer(target.app_id, target.app_secret)
def request(client, *args, **kwargs):
response, body = client.request(*args, **kwargs)
if response["status"] != "200":
raise TwitterAPIError(body)
return body
try:
oauth_token = cherrypy.request.params.get("oauth_token")
oauth_verifier = cherrypy.request.params.get("oauth_verifier")
oauth_secret_session_key = "twitter_auth.%s.oauth_secret" % self.id
if not oauth_token or not oauth_verifier:
# Obtain a request token
client = Client(consumer)
location = Location.get_current(relative=False)
location.query_string["item_action"] = self.id
callback = quote_plus(str(location))
body = request(
client, "https://api.twitter.com/oauth/request_token"
"?oauth_callback=" + callback, "GET")
data = dict(parse_qsl(body))
session[oauth_secret_session_key] = data["oauth_token_secret"]
# Redirect the user to the login form
auth_url = ("https://api.twitter.com/oauth/authorize?"
"oauth_token=%s"
"&oauth_callback=%s" %
(data["oauth_token"], callback))
raise cherrypy.HTTPRedirect(auth_url)
else:
token = Token(oauth_token, session[oauth_secret_session_key])
token.set_verifier(oauth_verifier)
client = Client(consumer, token)
body = request(client,
'https://api.twitter.com/oauth/access_token',
"POST")
data = dict(parse_qsl(body))
target.auth_token = data["oauth_token"]
target.auth_secret = data["oauth_token_secret"]
datastore.commit()
except TwitterAPIError, ex:
notify_user(translations(ex), category="error", transient=False)
def get_consumer_token(self):
# Setup
print("Prepare the CONSUMER Info")
verified = 'n'
while verified.lower() != 'y':
key = input('Input the CONSUMER_KEY: ')
secret = input('Input the CONSUMER_SECRET: ')
print('Consumer Key: %s' % str(key))
print('Consumer Secret: %s' % str(secret))
verified = input('Are you sure? (y/N) ')
self.customer_key = key
self.customer_secret = secret
self.consumer = Consumer(self.customer_key, self.customer_secret)
def verifySignature(self, secret):
"""See L{IOAuthCredentials#verifySignature}."""
consumer = Consumer(key=self.consumerKey, secret=secret)
oauthRequest = Request.from_request(self.method,
self.url,
headers=self.headers,
query_string=self.arguments)
# verify the request has been oauth authorized, we only support
# HMAC-SHA1, reject OAuth signatures if they use a different method
if self.signatureMethod != 'HMAC-SHA1':
raise NotImplementedError('Unknown signature method: %s' %
self.signatureMethod)
signatureMethod = SignatureMethod_HMAC_SHA1()
result = signatureMethod.check(oauthRequest, consumer, None,
self.signature)
return result
def get(self, ckey, csec):
"""
oauthを行う。
tokenを要求した後、PINの入力を受付け、
その結果、token情報を返す
"""
"""
リプライをパースするλ式
oauth_token=IE&oauth_token_secret=0x&oauth_callback_confirmed=true'
を
{'oauth_token_secret': '0x', 'oauth_token': 'IEb', 'oauth_callback_confirmed': 'true'}
のようにする
"""
parseparam = lambda x: dict(map(lambda y: y.split('='), x.split("&")))
# 設定ファイルに情報があるならそこからもらい返す
ukey, usec = self.getfromcfg()
if ukey != "" and usec != "":
return ((ukey, usec))
# oauth用のクラス定義
client = Client(Consumer(ckey, csec), None)
# トークンの要求
liRes = client.request(self.urlReqToken, 'GET')
diRes = parseparam(liRes[1])
# 得たトークンを基にPINの要求を行う
request_token = Token(diRes["oauth_token"],
diRes["oauth_token_secret"])
print("plz access: " + self.urlReqPin + request_token.key)
stPin = raw_input('PIN:')
request_token.set_verifier(stPin)
# 実際のキーをもらう
client.token = request_token
liRes = client.request(self.urlReqKey, 'POST')
# 情報をパースする
diRes = parseparam(liRes[1])
ukey = diRes["oauth_token"]
usec = diRes["oauth_token_secret"]
# 設定ファイルに書き込む
self.setcfg(ukey, usec)
return ((ukey, usec, diRes["user_id"], diRes["screen_name"]))
def auth(callback_url):
# setup
client = SimpleClient(SERVER, REQUEST_TOKEN_URL, ACCESS_TOKEN_URL)
consumer = Consumer(CONSUMER_KEY, CONSUMER_SECRET)
# get request token
oauth_request = Request.from_consumer_and_token(
consumer,
http_method="POST",
http_url=client.request_token_url,
parameters={'oauth_callback': callback_url})
oauth_request.sign_request(SignatureMethod_HMAC_SHA1(), consumer, None)
token = client.fetch_request_token(oauth_request)
cache.set('app.root.view.post::oauth_token', token.key, 300)
cache.set('app.root.view.post::oauth_token_secret', token.secret, 300)
oauth_request = Request.from_token_and_callback(token=token,
http_url=AUTHORIZATION_URL)
return oauth_request.to_url()
def get_access_token(self, callback):
path = self.get_oauth_path('get_access_token')
url = self.get_url(path)
consumer = Consumer(self.consumer.key, self.consumer.secret)
request_token = self.get_request_token(callback)
response = self.authorize_request_token(request_token.key)
params = dict(parse_qsl(response['Location'][len(callback)+1:]))
request_token.set_verifier(params['oauth_verifier'])
request = Request.from_consumer_and_token(consumer, request_token,
'POST', url)
request.sign_request(self.signature_method, consumer, request_token)
response = self.client.post(path, request)
self.assertEquals(response.status_code, 200)
params = dict(parse_qsl(response.content))
return Token(params['oauth_token'], params['oauth_token_secret'])
def make_request(self, url, method="GET", body="", headers=None):
"""Makes a request to the TradeKing API."""
consumer = Consumer(key=TRADEKING_CONSUMER_KEY,
secret=TRADEKING_CONSUMER_SECRET)
token = Token(key=TRADEKING_ACCESS_TOKEN,
secret=TRADEKING_ACCESS_TOKEN_SECRET)
client = Client(consumer, token)
self.logs.debug("TradeKing request: %s %s %s %s" %
(url, method, body, headers))
response, content = client.request(url, method=method, body=body,
headers=headers)
self.logs.debug("TradeKing response: %s %s" % (response, content))
try:
return loads(content)
except ValueError:
self.logs.error("Failed to decode JSON response: %s" % content)
return None
def fetch(self, username):
from droplet.stream.models import Location
try:
return self.get(username=username)
except self.model.DoesNotExist:
pass
client = Client(
Consumer(key=settings.TWITTER_CONSUMER_KEY,
secret=settings.TWITTER_CONSUMER_SECRET),
Token(key=settings.TWITTER_ACCESS_KEY,
secret=settings.TWITTER_ACCESS_SECRET))
response, content = client.request(
USER_URL + '?' + urlencode({'screen_name': username}))
if response.status != 200:
return
try:
content = simplejson.loads(content)
except:
return
url = content.get('url')
if url:
try:
url = urlopen(url).url
except:
pass
return self.create(username=content.get('screen_name'),
display_name=content.get('name'),
description=content.get('description'),
image=content.get('profile_image_url'),
location=Location.objects.fetch(
content.get('location')),
url=url)
def publish(self, publishable):
if self.auth_token is None:
raise ValueError(
"Can't publish %s to %s: authorization token missing" %
(publishable, self))
if self.auth_secret is None:
raise ValueError(
"Can't publish %s to %s: authorization secret missing" %
(publishable, self))
consumer = Consumer(self.app_id, self.app_secret)
token = Token(self.auth_token, self.auth_secret)
client = Client(consumer, token)
status = self.get_status(publishable)
response, body = client.request(
"https://api.twitter.com/1/statuses/update.json", "POST",
urlencode({"status": status.encode("utf-8")}))
if response["status"] != "200":
raise TwitterAPIError(body)
def __init__(self, data_file, client_id, client_secret):
Source.__init__(self, data_file)
self.consumer = Consumer(client_id, client_secret)
self.access_token = None
def __init__(self, consumer_key, consumer_secret):
self.consumer = Consumer(consumer_key, consumer_secret)
