class PlurkOAuthApi:
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 request_token(self) -> dict:
url = urljoin(self.base_url, "/OAuth/request_token")
header, content = self.client.request(url, "POST")
return parse_qs(content)
def authorization_url(self, request_token: dict):
return urljoin(
self.base_url,
f"/OAuth/authorize?oauth_token={request_token['oauth_token']}")
def access_token(self, request_token: dict, verifier: str) -> dict:
url = urljoin(self.base_url, "/OAuth/access_token")
token = Token(request_token["oauth_token"],
request_token["oauth_token_secret"])
token.set_verifier(verifier)
self.client.token = token
header, content = self.client.request(url, "POST")
return parse_qs(content)
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 oauth_request(url: str, oauth_client: oauth.Client, method: str ='GET', data: dict=None):
"""
Method to request url given an authenticated oauth client
"""
if method == 'GET':
resp = oauth_client.request(url)
else:
resp = oauth_client.request(url, 'POST', urlencode(data))
status_code = int(resp[0]['status'])
json_body = json.loads(resp[1].decode('UTF-8'))
return {'status_code': status_code, 'json': json_body}
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 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."
class ContextIO(object):
url_base = "https://api.context.io"
def __init__(self, consumer_key, consumer_secret):
self.consumer = Consumer(key=consumer_key, secret=consumer_secret)
self.client = Client(self.consumer)
self.client.set_signature_method(sha1())
self.base_uri = '2.0'
def request_uri(self, uri, method="GET", params={}, headers={}):
url = '/'.join((self.url_base, self.base_uri, uri))
response, body = self.request(url, method, params, headers)
status = int(response['status'])
if status in (200, 201) :
body = json.loads(body)
return body
else:
self.handle_request_error(response, body)
def request(self, url, method, params, headers):
query_params = urlencode(params)
if params and method == 'GET':
url += '?' + query_params
return self.client.request(url, method, headers=headers)
return self.client.request(url, method, query_params, headers=headers)
def get_accounts(self):
return [Account(self, obj) for obj in self.request_uri('accounts')]
def post_account(self, email, first_name=None, last_name=None):
pass
def delete_account(self, account_id):
pass
def put_account(self, first_name=None, last_name=None):
pass
def handle_request_error(self, response, body):
messages = []
try:
body = json.loads(body)
raise Exception('HTTP {status}: {message}'.format(status=response['status'], message=body['value']))
except ValueError:
raise Exception('HTTP {status}: {body}'.format(status=response['status'], body=body))
def refresh_tokens(self):
"""Refreshes Questrade's access tokens. Must be run before expires_in."""
url = QUESTRADE_AUTH_API_URL % __builtin__.QUESTRADE_REFRESH_TOKEN
method = "GET"
body = ""
headers = None
client = Client(None, None)
self.logs.debug("Questrade request: %s %s %s %s" %
(url, method, body, headers))
response, content = client.request(url,
method=method,
body=body,
headers=headers)
self.logs.debug("Questrade response: %s %s" % (response, content))
try:
response = loads(content)
self.access_token = response['access_token']
self.api_server = response['api_server']
self.expires_in = datetime.now() + datetime.timedelta(
0, response['expires_in'])
__builtin__.QUESTRADE_REFRESH_TOKEN = response['refresh_token']
self.token_type = response['token_type']
except ValueError:
self.logs.error("Failed to retrieve new API tokens: %s" % content)
def post(self, obj, access_token):
site = Site.objects.get_current()
token = Token(
key = ''.join(access_token.get('oauth_token')),
secret = ''.join(access_token.get('oauth_token_secret')),
)
title = unicode(obj)
content_type = unicode(obj._meta.verbose_name)
url = self.shorten_url('http://%s%s' % (site.domain, obj.get_absolute_url()))
prefix = 'I\'ve just commented on the '
pattern = u'%s%s %s %s'
title_avail = 140 - len(prefix) - (len(url) + 1) - (len(content_type) + 1)
while len(title) > title_avail:
before_space, space, after_space = title[:title_avail - 3].rpartition(' ')
title = before_space + '...'
text = pattern % (prefix, content_type, title, url)
client = Client(self.consumer(), token)
response, content = client.request(self.post_url, 'POST',
body = 'status=%s' % urlquote(text)
)
json = simplejson.loads(content)
if json.get('error'):
raise Exception(resp['error'])
if json.get('id'):
return True
raise Exception(json)
def tweet(message, key, secret, auth_key):
"""
get access key and call twitter api.
>>> tweet_with_auth("hello", "key", "secret", "verifier")
:param message: message to tweet
:type key: str
:param key:
:type key: str
:param secret:
:type key: str
:param auth_key: authorize key
:type key: str
:returns: result call api
:rtype: dict, dict
"""
post_body = "status={}".format(message)
# tweet
client = Client(Consumer(V.CONSUMER_KEY, V.CONSUMER_SECRET),
Token(key, secret))
res, content = client.request(V.STATUSES_UPDATE_URL,
method="POST",
body=post_body )
set_cache(auth_key, V.TW_RESPONCE, res)
set_cache(auth_key, V.TW_CONTENT, content)
return res, content
def __init__(self, logs_to_cloud):
self.logs = Logs(name="trading", to_cloud=logs_to_cloud)
# Get initial API keys from Questrade
url = QUESTRADE_AUTH_API_URL % __builtin__.QUESTRADE_REFRESH_TOKEN
method = "GET"
body = ""
headers = None
client = Client(None, None)
self.logs.debug("Questrade request: %s %s %s %s" %
(url, method, body, headers))
response, content = client.request(url,
method=method,
body=body,
headers=headers)
self.logs.debug("Questrade response: %s %s" % (response, content))
try:
response = loads(content)
self.access_token = response['access_token']
self.api_server = response['api_server']
self.expires_in = datetime.now() + datetime.timedelta(
0, response['expires_in'])
__builtin__.QUESTRADE_REFRESH_TOKEN = response['refresh_token']
self.token_type = response['token_type']
except ValueError:
self.logs.error("Failed to retrieve initial API tokens: %s" %
content)
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 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 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_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
class Tweeter(object):
def __init__(self, consumer_key, consumer_secret, user_key, user_secret):
self._consumer = Consumer(consumer_key, consumer_secret)
self._token = Token(user_key, user_secret)
self._client = Client(self._consumer, self._token)
def tweet(self, content):
return self._client.request('https://api.twitter.com/1.1/statuses/update.json', 'POST', urlencode({'status': content}))
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 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 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(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 make_api_call(self, kind, url, token, method="GET", **kwargs):
if isinstance(token, basestring):
token = Token.from_string(token)
client = Client(self.consumer, token=token)
request_kwargs = dict(method=method)
if method == "POST":
request_kwargs["body"] = urlencode(kwargs["params"])
response, content = client.request(url, **request_kwargs)
return self._process_response(kind, response, content)
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 login():
# リクエストトークンの取得
client = Client(consumer)
print "client : %s" %client
resp, content = client.request('%s?scope=%s&oauth_callback=%s%s' % \
(REQUEST_TOKEN_URL, SCOPE, request.host_url,'on-auth'))
# セッションへリクエストトークンを保存しておく
session['request_token'] = dict(urlparse.parse_qsl(content))
# 認証用URLにリダイレクトする
return redirect('%s?oauth_token=%s' % (AUTHENTICATE_URL, session['request_token']['oauth_token']))
def on_auth():
# リクエストトークンとverifierを用いてアクセストークンを取得
request_token = session['request_token']
token = Token(request_token['oauth_token'], request_token['oauth_token_secret'])
token.set_verifier(request.args['oauth_verifier'])
client = Client(consumer, token)
resp, content = client.request(ACCESS_TOKEN_URL)
# アクセストークンをセッションに記録しておく
session['access_token'] = dict(urlparse.parse_qsl(content))
return redirect(url_for('index'))
def oauthdance(
consumer_key,
consumer_secret,
request_token_url="http://twitter.com/oauth/request_token",
authorize_url="http://twitter.com/oauth/authorize",
access_token_url="http://twitter.com/oauth/access_token",
):
"""
"""
from oauth2 import Consumer, Client, Token
from urlparse import parse_qsl
con = Consumer(consumer_key, consumer_secret)
cli = Client(con)
res, bod = cli.request(request_token_url, "GET")
assert res["status"] == "200", "Expected status=200, got %s." % res["status"]
tok = dict(parse_qsl(bod))
tok = Token(tok["oauth_token"], tok["oauth_token_secret"])
print "Visit this URL to get a PIN:"
print " %s?oauth_token=%s" % (authorize_url, tok.key)
pin = raw_input("PIN: ").strip()
tok.set_verifier(pin)
cli = Client(con, tok)
res, bod = cli.request(access_token_url, "GET")
assert res["status"] == "200", "Expected status=200, got %s." % res["status"]
tok = dict(parse_qsl(bod))
tok = Token(tok["oauth_token"], tok["oauth_token_secret"])
print "Your token key is: ", tok.key
print "And your secret is:", tok.secret
return tok
class ContextIO(object):
url_base = "https://api.context.io"
def __init__(self, consumer_key, consumer_secret):
self.consumer = Consumer(key=consumer_key, secret=consumer_secret)
self.client = Client(self.consumer)
self.client.set_signature_method(sha1())
self.base_uri = '2.0'
def request_uri(self, uri, method="GET", params={}, headers={}):
url = '/'.join((self.url_base, self.base_uri, uri))
response, body = self.request(url, method, params, headers)
status = int(response['status'])
if status >= 200 and status < 300:
body = json.loads(body)
return body
else:
self.handle_request_error(response, body)
def request(self, url, method, params, headers):
body = ''
if method == 'GET' and params:
url += '?' + urlencode(params)
elif method == 'POST' and params:
body = urlencode(params)
print method + ' ' + url
return self.client.request(url, method, headers=headers, body=body)
def get_accounts(self, **params):
params = Resource.sanitize_params(params, ['email', 'status', 'status_ok', 'limit', 'offset'])
return [Account(self, obj) for obj in self.request_uri('accounts', params=params)]
def post_account(self, email, **params):
params = Resource.sanitize_params(params, ['first_name', 'last_name'])
params['email'] = email
return Account(self, self.request_uri('accounts', method="POST", params=params))
def delete_account(self, account_id):
pass
def put_account(self, first_name=None, last_name=None):
pass
def handle_request_error(self, response, body):
try:
import logging
logging.info('body '+str(body))
body = json.loads(body)
raise Exception('HTTP %(status)s - %(type)s %(code)s: %(message)s' % { 'status': response['status'], 'type': body['type'], 'code': body['code'], 'message': body['value']})
except ValueError:
raise Exception('HTTP %(status)s: %(body)s' % {'status':response['status'], 'body':body})
def get_user_inf():
user = {}
access_token = session.get('access_token')
print access_token
if access_token:
# access_tokenなどを使ってAPIにアクセスする
token = Token(access_token['oauth_token'], access_token['oauth_token_secret'])
client = Client(consumer, token)
resp, content = client.request('http://n.hatena.com/applications/my.json')
if content != 'oauth_problem=token_rejected':
user = json.loads(content)
return user
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 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 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
class ContextIO(object):
url_base = "https://api-preview.context.io"
def __init__(self, consumer_key, consumer_secret):
self.consumer = Consumer(key=consumer_key, secret=consumer_secret)
self.client = Client(self.consumer)
self.client.set_signature_method(sha1())
self.base_uri = '2.0'
def request_uri(self, uri, method="GET", params={}, headers={}):
url = '/'.join((self.url_base, self.base_uri, uri))
response, body = self.request(url, method, params, headers)
status = int(response['status'])
if status == 200:
body = json.loads(body)
return body
else:
self.handle_request_error(response, body)
def request(self, url, method, params, headers):
if params:
url += '?' + urlencode(params)
print "{method} {url}".format(url=url, method=method)
return self.client.request(url, method, headers=headers)
def get_accounts(self):
return [Account(self, obj) for obj in self.request_uri('accounts')]
def post_account(self, email, first_name=None, last_name=None):
pass
def delete_account(self, account_id):
pass
def put_account(self, first_name=None, last_name=None):
pass
def handle_request_error(self, response, body):
messages = []
try:
body = json.loads(body)
for message in body['messages']:
if message['type'] == 'error':
messages.append("error {0}".format(message['code']))
raise Exception('HTTP {status}: {message}'.format(status=response['status'], message=', '.join(messages)))
except ValueError:
raise Exception('HTTP {status}: {body}'.format(status=response['status'], body=body))
def get_twitter_user_info(url, app, access_token, access_token_secret):
token = Token(access_token, access_token_secret)
consumer = Consumer(app.key, app.secret)
client = Client(consumer, token)
method="GET"
params=dict()
headers=dict()
body = urllib.urlencode(params)
response, content = client.request(url, method=method, headers=headers, body=body)
if response['status'] != '200':
raise OAuthError('OAuth Error')
return content
def oauth_req(backend, token, url, http_method="GET", post_body=None,
http_headers=None):
consumer = OAuthConsumer(*backend.get_key_and_secret())
token = Token.from_string(token)
client = Client(consumer, token)
resp, content = client.request(
url,
method=http_method,
body=post_body,
headers=http_headers,
force_auth_header=True
)
return content
def request(self, method, url, query=''):
client = Client(self.consumer, self.token)
headers, body = client.request(self.BASE + url, method=method, body=query)
status = headers.get('status')
json = None
try:
if status < '500':
json = loads(body)
except ValueError:
logging.warn(traceback.format_exc())
logging.warn(body)
return status == '200', status, json
def request(self, method, url, query=''):
client = Client(self.consumer, self.token)
headers, body = client.request(self.BASE + url,
method=method,
body=query)
status = headers.get('status')
json = None
try:
if status < '500':
json = loads(body)
except ValueError:
logging.warn(traceback.format_exc())
logging.warn(body)
return status == '200', status, json
def search_twitter(term):
"""Query the Twitter API for term and return statuses that match
Returns a list of dictionaries.
Each dictionary has these keys: title, description, url"""
url = settings.TWITTER_SEARCH_BASE_URL + term
client = Client(Consumer(key=settings.TWITTER_CONSUMER_KEY,
secret=settings.TWITTER_CONSUMER_SECRET))
resp, content = client.request(url, method="GET")
raw_data = json.loads(content)
data = [
{"title": "", "description": status["text"],
"url": "https://twitter.com/statuses/{id}".format(id=status["id"])}
for status in raw_data["statuses"]
]
return data
def index():
consumer = Consumer(key=consumer_key, secret=consumer_secret)
client = Client(consumer)
resp, content = client.request(request_token_url, "GET")
if resp['status'] != '200':
redirect(URL(r=request, f='maintenance'))
# Turn response into dict
request_token = dict(parse_qsl(content))
# Store it in a session
session.request_token = request_token
redirect_location = "%s?oauth_token=%s" % (authorize_url, request_token['oauth_token'])
redirect(redirect_location)
class PlurkApi:
def __init__(self, api_key: str, api_secret: str, token_key: str, token_secret: str,
base_url: str = "https://www.plurk.com", **kwargs):
consumer = Consumer(api_key, api_secret) # type:Consumer
token = Token(token_key, token_secret) # type:Token
self.client = Client(consumer, token, **kwargs) # type:Client
self.base_url = base_url # type:str
def request(self, end_point: str, parameters: Union[dict, str] = None) -> dict:
if isinstance(parameters, dict):
parameters = urlencode(parameters)
if isinstance(parameters, str):
parameters = parameters.encode()
else:
parameters = None
url = urljoin(self.base_url, end_point)
header, content = self.client.request(url, "POST", parameters)
return loads(content.decode())
def twitter(self, request, **kwargs):
self.method_check(request, allowed=['post'])
postData = simplejson.loads(request.raw_post_data)
twId = postData['id']
token = postData['token']
tokenSecret = postData['tokenSecret']
#chek if user exists
try:
user = UserSocialAuth.objects.get(uid=twId,provider='twitter')
key = getOrCreateKey(user.user)
return self.create_response(request,{'status':OK,
'token':key})
except UserSocialAuth.DoesNotExist:
#verify credentials against twitter API
consumer = OAuthConsumer(TWITTER_CONSUMER_KEY,
TWITTER_CONSUMER_SECRET)
uToken = Token(token, tokenSecret)
client = OAuthClient(consumer,uToken)
res, content = client.request(TWITTER_CHECK_AUTH, "GET")
if res['status'] == '200':
#credentials aproved
contentJson = simplejson.loads(content)
finalName = make_social_username(contentJson['screen_name'])
newUser = User.objects.create_user(username=finalName,
email="")
extraData = simplejson.dumps({u'access_token':u'oauth_token_secret=%s&oauth_token=%s',u'id': twId}) % (token, tokenSecret)
newSocialU = UserSocialAuth.objects.create(user=newUser,
provider='twitter',
uid=twId,
extra_data= extraData)
newSocialU.save()
key = getOrCreateKey(newUser)
return self.create_response(request,{'status':OK,
'token':key})
else:
#credentials rejected
return self.create_response(request,{'status': UNAUTHORIZED,
'error':'Twitter credentials denied'})
def oauth_req(backend, token, url, http_method="GET", post_body=None,
http_headers=None):
CONSUMER_KEY, CONSUMER_SECRET = get_keys(backend.name)
consumer = OAuthConsumer(key=CONSUMER_KEY, secret=CONSUMER_SECRET)
token = Token.from_string(token)
client = Client(consumer, token)
resp, content = client.request(
url,
method=http_method,
body=post_body,
headers=http_headers,
force_auth_header=True
)
print resp
return content
def request(self, url, params=None, data=None):
# Setup
if self.oauth_token:
self.token = Token(self.oauth_token['oauth_token'],
self.oauth_token['oauth_token_secret'])
client = Client(self.consumer, self.token)
req = self._make_request(self.base_url + url, data)
# Get Request Token
encoded_content = None
if data:
encoded_content = urlencode(data)
resp, content = client.request(self.base_url + url, "POST",
headers=req.to_header(), body=encoded_content)
# for python3
if isinstance(content, bytes):
content = content.decode('utf-8')
return resp['status'], content, resp.reason
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 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 request(self, url, params=None, data=None):
# Setup
if self.oauth_token:
self.token = Token(self.oauth_token['oauth_token'],
self.oauth_token['oauth_token_secret'])
client = Client(self.consumer, self.token)
req = self._make_request(self.base_url + url, params)
# Get Request Token
encoded_content = None
if data:
encoded_content = urlencode(data)
resp, content = client.request(self.base_url + url, "POST",
headers=req.to_header(), body=encoded_content)
# for python3
if isinstance(content, bytes):
content = content.decode('utf-8')
return resp['status'], content, resp.reason
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 finalise_connection(self, **kwargs):
client = Client(self.consumer())
response, content = client.request(self.access_token_url, 'POST',
body = 'oauth_token=%s&oauth_verifier=%s' % (
urlquote(kwargs['oauth_token']),
urlquote(kwargs['oauth_verifier'])
)
)
try:
details = parse_qs(content)
except:
raise Exception('Unrecognised response')
if not 'oauth_token' in details:
raise Exception('Site has not returned an OAuth token')
if not 'oauth_token_secret' in details:
raise Exception('Site has not returned an OAuth secret')
return details
def get_identity(self, access_token):
token = Token(
key = ''.join(access_token.get('oauth_token')),
secret = ''.join(access_token.get('oauth_token_secret')),
)
client = Client(self.consumer(), token)
response, content = client.request(self.identity_url, 'GET')
json = simplejson.loads(content)
if json:
if 'error' in json:
raise Exception('An error occurred obtaining the identity')
return {
'username': json['screen_name'],
'display_name': json['name'],
'url': u'http://twitter.com/%s' % json['screen_name'],
'id': json['id']
}
raise Exception(json)
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 make_request(self, url, method="GET", body="", headers=None):
"""Makes a request to the Questrade API."""
client = Client(None, None)
if headers is None:
headers = {
'Authorization':
("%s %s" % (self.token_type, self.access_token))
}
self.logs.debug("Questrade request: %s %s %s %s" %
(url, method, body, headers))
response, content = client.request(url,
method=method,
body=body,
headers=headers)
self.logs.debug("Questrade response: %s %s" % (response, content))
try:
return loads(content)
except ValueError:
self.logs.error("Failed to decode JSON response: %s" % content)
return None
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)
from oauth2 import Client, Token, Consumer
import twitter_key
consumer_key = twitter_key.C_KEY
consumer_secret = twitter_key.C_SECRET
def split_parameter(parameters):
result_list = [tuple(parameter.split('='))
for parameter in parameters.split('&')]
return dict(result_list)
consumer = Consumer(consumer_key, consumer_secret)
client = Client(consumer, None)
result = client.request('http://api.twitter.com/oauth/request_token',
'GET')
request_token_map = split_parameter(result[1])
request_token = Token(request_token_map['oauth_token'],
request_token_map['oauth_token_secret'])
print 'Please access "http://api.twitter.com/oauth/authorize?oauth_token='+request_token.key+'".'
pin = raw_input('PIN:')
request_token.set_verifier(pin)
client.token = request_token
result = client.request('http://api.twitter.com/oauth/access_token',
'POST')
access_token_map = split_parameter(result[1])
print result[1]
print 'User key: '+access_token_map['oauth_token']
class ContextIO(object):
url_base = "https://api.context.io"
def __init__(self, consumer_key, consumer_secret):
self.consumer = Consumer(key=consumer_key, secret=consumer_secret)
self.client = Client(self.consumer)
self.client.set_signature_method(sha1())
self.base_uri = '2.0'
def request_uri(self, uri, method="GET", params={}, headers={}):
url = '/'.join((self.url_base, self.base_uri, uri))
response, body = self.request(url, method, params, headers)
status = int(response['status'])
if status >= 200 and status < 300:
body = json.loads(body)
return body
else:
self.handle_request_error(response, body)
def request(self, url, method, params, headers):
body = ''
if method == 'GET' and params:
url += '?' + urlencode(params)
elif method == 'POST' and params:
body = urlencode(params)
print method + ' ' + url
return self.client.request(url, method, headers=headers, body=body)
def get_accounts(self, **params):
params = Resource.sanitize_params(
params, ['email', 'status', 'status_ok', 'limit', 'offset'])
return [
Account(self, obj)
for obj in self.request_uri('accounts', params=params)
]
def post_account(self, email, **params):
params = Resource.sanitize_params(params, ['first_name', 'last_name'])
params['email'] = email
return Account(
self, self.request_uri('accounts', method="POST", params=params))
def delete_account(self, account_id):
pass
def put_account(self, first_name=None, last_name=None):
pass
def handle_request_error(self, response, body):
try:
body = json.loads(body)
raise Exception(
'HTTP %(status)s - %(type)s %(code)s: %(message)s' % {
'status': response['status'],
'type': body['type'],
'code': body['code'],
'message': body['value']
})
except ValueError:
raise Exception('HTTP %(status)s: %(body)s' % {
'status': response['status'],
'body': body
})
def fetch(self):
from droplet.stream.models import Company, Customer
client = Client(
Consumer(key=settings.TWITTER_CONSUMER_KEY,
secret=settings.TWITTER_CONSUMER_SECRET),
Token(key=settings.TWITTER_ACCESS_KEY,
secret=settings.TWITTER_ACCESS_SECRET))
params = {
'q': 'via @dropletpay',
'result_type': 'recent',
'count': 100
}
try:
params['since_id'] = self.latest().remote_id
except self.model.DoesNotExist:
pass
qs = urlencode(params)
response, content = client.request(SEARCH_URL + '?' + qs)
while True:
if response.status != 200:
break
try:
content = simplejson.loads(content)
except:
break
for tweet in content.get('statuses', []):
message = tweet.get('text')
if not message:
continue
user = tweet.get('user')
if not user:
continue
match = REGEX.search(message)
if match is None:
continue
username, amount, item, notes = match.groups()
if not username:
continue
try:
amount = float(amount)
except:
continue
company = None
if username.startswith('@'):
for mention in tweet.get('entities',
{}).get('user_mentions', []):
if mention.get('screen_name') == username[1:]:
company = Company.objects.fetch(username[1:])
if company is None:
continue
break
if company is None:
company = Company.objects.fetch(username[1:])
if company is None:
continue
else:
company, created = Company.objects.get_or_create(
display_name=username)
try:
customer = Customer.objects.get(
username=user.get('screen_name'))
except Customer.DoesNotExist:
customer = Customer.objects.create(
username=user.get('screen_name'),
display_name=user.get('name'))
offset = user.get('utc_offset')
if offset is None:
offset = 0
payment = self.create(
company=company,
customer=customer,
item=item,
amount=str(amount),
remote_id=tweet.get('id'),
date=(parse(tweet.get('created_at')) +
timedelta(seconds=offset)).replace(tzinfo=utc))
qs = content.get('search_metadata', {}).get('next_results')
if not qs:
break
response, content = client.request(SEARCH_URL + '?' + qs)
class ContextIO(object):
url_base = "https://api.context.io"
def __init__(self, consumer_key, consumer_secret, timeout=None):
self.consumer = Consumer(key=consumer_key, secret=consumer_secret)
self.client = Client(self.consumer, timeout=timeout)
self.client.set_signature_method(sha1())
self.base_uri = '2.0'
def request_uri(self,
uri,
method="GET",
params=None,
headers=None,
data={}):
if params is None:
params = {}
if headers is None:
headers = {}
url = '/'.join((self.url_base, self.base_uri, uri))
response, body = self.request(url, method, params, headers, data=data)
status = int(response['status'])
if status >= 200 and status < 300:
# file content doesn't return json
if re.match(r'accounts/\w+/files/\w+/content', uri):
return body
# message source doesn't return json
if re.match(r'accounts/\w+/messages/\w+/source', uri):
return body
body = json.loads(body)
return body
else:
self.handle_request_error(response, body)
def request(self, url, method, params, headers, data=''):
body = ''
if method == 'GET' and params:
url += '?' + urlencode(params)
elif method == 'POST' and params:
body = urlencode(params, doseq=True)
if data:
body = json.dumps(data)
print method + ' ' + url
return self.client.request(url, method, headers=headers, body=body)
def get_accounts(self, **params):
params = Resource.sanitize_params(
params, ['email', 'status', 'status_ok', 'limit', 'offset'])
return [
Account(self, obj)
for obj in self.request_uri('accounts', params=params)
]
def get_account(self, account_id):
return Account(self, self.request_uri('accounts/%s' % account_id))
def post_account(self, email, **params):
params = Resource.sanitize_params(params, ['first_name', 'last_name'])
params['email'] = email
return Account(
self, self.request_uri('accounts', method="POST", params=params))
def delete_account(self, account_id):
pass
def put_account(self, first_name=None, last_name=None):
pass
def get_connect_tokens(self):
return [
ConnectToken(self, obj)
for obj in self.request_uri('connect_tokens')
]
def get_connect_token(self, token):
obj = self.request_uri('connect_tokens/%s' % token)
return ConnectToken(self, obj)
def post_connect_token(self, callback_url, **params):
params = Resource.sanitize_params(params, [
'service_level', 'email', 'first_name', 'last_name',
'source_callback_url', 'source_sync_flags', 'source_raw_file_list'
])
params['callback_url'] = callback_url
resp = self.request_uri('connect_tokens', method='POST', params=params)
token = resp['token']
redirect_url = resp['browser_redirect_url']
return (token, redirect_url)
def handle_request_error(self, response, body):
status_code = int(response['status'])
try:
body = json.loads(body)
raise RequestError(
status_code,
'HTTP %(status)s - %(type)s %(code)s: %(message)s' % {
'status': response['status'],
'type': body['type'],
'code': body['code'],
'message': body['value']
})
except (ValueError, TypeError, KeyError):
raise RequestError(
status_code, 'HTTP %(status)s: %(body)s' % {
'status': response['status'],
'body': body
})
# -*- coding: utf-8 -*-
from urllib import urlencode
from oauth2 import Client, Consumer, Token
consumer_key = '03qZsTOrjpcKnDotiwhC5g'
consumer_secret = 'R9OYu68Wy6YgxmI8IbKPVIHrzeeANNmvjqvxPIXQE'
user_key = '174199131-ddgdSao7zUDMBbv63SnafaMopRlYXifW7wDqOLWR'
user_secret = 'R4h1u1bgndCqNUI1On9Cs3dGaPRN2btru5b2XVi11D0'
client = Client(Consumer(consumer_key, consumer_secret),
Token(user_key, user_secret))
client.request('http://api.twitter.com/1/statuses/update.xml', 'POST',
urlencode({'status': 'こんにちは'}))
class Twitter(object):
fnCache = "./.cache.twitter"
objCache = {}
urlUpdate = "https://api.twitter.com/1.1/statuses/update.json"
urlFriendIds = "https://api.twitter.com/1.1/friends/ids.json"
urlSearchTweet = "https://api.twitter.com/1.1/search/tweets.json"
def _override_tourl(self):
"""Serialize as a URL for a GET request."""
base_url = urlparse.urlparse(self.url)
try:
query = base_url.query
except AttributeError:
# must be python <2.5
query = base_url[4]
query = parse_qs(query)
for k, v in self.items():
query.setdefault(k, []).append(v)
try:
scheme = base_url.scheme
netloc = base_url.netloc
path = base_url.path
params = base_url.params
fragment = base_url.fragment
except AttributeError:
# must be python <2.5
scheme = base_url[0]
netloc = base_url[1]
path = base_url[2]
params = base_url[3]
fragment = base_url[5]
url = (scheme, netloc, path, params, urllib.urlencode(query,
True), fragment)
return urlparse.urlunparse(url)
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)
def _write_Cache(self):
with open(self.fnCache, 'wb') as f:
pickle.dump(self.objCache, f)
def _set_Cache(self, name, val):
print("setCache:" + name + "-" + val)
curDate = datetime.datetime.now()
self.objCache[name] = (curDate, val)
def _get_Cache(self, name, timeout=0):
print("getCache:" + name)
# キャッシュがそもそも存在しなければNoneを返す
if not name in self.objCache:
return None
# 現在の時刻とキャッシュの時刻を比較する
curDate = datetime.datetime.now()
(cacheDate, val) = self.objCache[name]
deltaDate = curDate - cacheDate
# 指定されたキャッシュ期限をすぎていた場合、なにも返さない
if deltaDate.seconds > timeout:
return None
# キャッシュ期間内であればキャッシュの値を返す
return val
def _handle_error(self, stErrors):
"""
errorは
{"errors":[{"code":187,"message":"Status is a duplicate."}]}
のようにはいる
"""
liErrors = json.loads(stErrors)
for diError in liErrors.get("errors", []):
print(diError['message'])
def post(self, content):
res = self.client.request(self.urlUpdate, 'POST',
urlencode({"status": content}))
stRetcode = res[0]['status']
# 200のときのみ抜ける
if stRetcode == "200":
return (True)
self._handle_error(res[1])
def get_friend_ids(self):
friend_ids = self._get_Cache("friend_ids", timeout=1800)
if friend_ids:
return friend_ids
res = self.client.request(self.urlFriendIds, 'GET')
stRetcode = res[0]['status']
# 200のときのみ抜ける
if stRetcode == "200":
friend_ids = res[1]
self._set_Cache("friend_ids", friend_ids)
self._write_Cache()
return friend_ids
# print json.dumps(res, indent=4)
def search_tweets(self, keyword):
args = dict()
args["q"] = "ほげ"
#args["result_type"] = "recent"
#args["count"] = "10"
#args["include_entities"] = "True"
params = urlencode(
dict([k, v.encode('utf-8') if isinstance(v, unicode) else v]
for k, v in args.items()))
"""
params={}
print args
for k, v in args.iteritems():
if isinstance(v, unicode):
params[k] = unicode(v).encode('utf-8')
else:
params[k] = v
params = urlencode(params)
"""
print params
url = self.urlSearchTweet + "?" + params
url = "https://api.twitter.com/1.1/search/tweets.json?q=%e3%82%82%e3%81%92"
print url
res = self.client.request(url)
print json.dumps(res, indent=4)
def make_request(eslf,url,method="GET", body="",headers=None):
"""Makes request to 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)
body_bytes=body.encode("utf-8")
self.logs.debug("TradeKing request: %s %s %s %s" % (ul,method, body_bytes,headers))
response,content=client.request(url,method=method,body=body_bytes,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 xml_tostring(self,xml):
"""Generates string representation to XML"""
return toString(xml,encoding="utf-8").decode("utf-8")
def fixml_buy_now(self,ticker,quantity,limit):
"""Generates FIXML for a buy order"""
fixml=Element("FIXML")
fixml.set("xmlns",FIXML_NAMESPACE)
order=SubElement(fixml,"Order")
order.set("TmInForce","0") #day order
order.set("Typ","2") #limit
order.set("Side","1") #Buy
order.set("Px","%.2f" % limit) #Limit price
order.set("Acct",TRADEKING_ACCOUNT_NUMBER)
instrmt=SubElement(order,"Instrmt")
instrmt.set("SecTyp","CS") #Common stock
instrmt.set("Sym",ticker)
ord_qty=SubElement(order,"OrdQty")
ord_qty.set("Qty",str(quantity))
return self.xml_tostring(fixml)
def fixml_sell_eod(self, ticker, quantity,limit):
""" Generates FIXML for a sell order"""
fixml=Element("FIXML")
fixml.set("xmlns",FIXML_NAMESPACE)
order=SubElement(fixml,"Order")
order.set("TmInForce","7") #Market on close
order.set("Typ","2") #Limit
order.set("Side","2") #Sell
order.set("Px","%.2f"%limit) #Limit price
order.set("Acct",TRADEKING_ACCOUNT_NUMBER)
instrmt=SubElement(order,"Instrmt")
instrmt.set("SecTyp","CS") #Common stock
instrmt.set("Sym",ticker)
ord_qty=SubElement(order,"OrdQty")
ord_qty.set("Qty",str(quantity))
return self.xml_tostring(fixml)
def fixml_short_now(self,ticker,quantity,limit):
""" Generates FIXML for sell short order"""
fixml=Element("FIXML")
fixml.set("xmlns",FIXML_NAMESPACE)
order=SubElement(fixml,"Order")
order.set("TmInFore","0") #Day order
order.set("Typ","2") #Limit
order.set("Side","5") #Sell short
order.set("Px","%.2f"%limit) #Limit price
order.set("Acct",TRADEKING_ACCOUNT_NUMBER)
instrmt=SubElement(order,"Instrmt")
instrmt.set("SecTyp","CS") #Common stock
instrmt.set("Sym",ticker)
ord_qty=SubElement(order,"OrdQty")
ord_qty.set("Qty",str(quantity))
return self.xml_tostring(fixml)
def fixml_cover_eod(self,ticker,quantity,limit):
"""Generates FIXML for a sell to cover order"""
fixml=Element("FIXML")
fixml.set("xmlns",FIXML_NAMESPACE)
order=SubElement(fixml,"Order")
order.set("TmInForce","7") #Market on close
order.set("Typ","2") #Limit
order.set("Side","1") #Buy
order.set("Px","%.2f"% limit) #Limit price
order.set("AcctType"."5") #Cover
order.set("Acct",TRADEKING_ACCOUNT_NUMBER)
instrmt=SubElement(order,"Instrmt")
instrmt.set("SecTyp","CS") #Common stock
instrmt.set("Sym",ticker)
ord_qty=SubElement(order,"OrdQty")
ord_qty.set("Qty",str(quantity))
return self.xml_tostring(fixml)
def get_buy_limit(self,price):
""" Calculates limit price for buy (or cover) order"""
return round((1+LIMIT_REACTION)*price,2)
def get_sell_limit(self,price):
"""Calculates limit price for sell(or short) order"""
return round((1-LIMIT_FRACTION)*price,2)
def get_balance(self):
"""Finds cash balance in dollars available to spend"""
balances_url=TRADEKING_API_URL %("accounts/%s"% TRADEKING_ACCOUNT_NUMBER)
response=self.make_request(url=balances_url)
if not response:
self.logs.erroor("No balances response")
return 0
try:
balances=response["response"]
money=balances["accountbalance"]["money"]
cash_str=money["cash"]
uncleareddeposits_str=money["uncleareddeposits"]
except KeyError:
self.logs.error("Malformed balances response: %s" % response)
return 0
try:
cash=float(cash_str)
uncleareddeposits=float(uncleareddeposits_str)
return cash-uncleareddeposits
except ValueError:
self.logs.error("Malformed number in response: %s"% money)
return 0
def get_last_price(self,ticker):
""" Finds last trade price for specified stock"""
quotes_url=TRADEKING_API_URL % "market/text/quotes"
quotes_url+="?symbols=%s" % ticker
quotse_url+="&fids==last,date,symbol,exch_desc,name"
response=self.make_request(url=quotes_url)
if not response:
self.logs.error("No quotes response for %s: %s"%(ticker,response))
return None
try:
quotes=response["response"]
quote=quotes["quotes"]["quote"]
last_str=quote["last"]
except KeyError:
self.logs.error("malformed quotes response: %s"% response)
return None
self.logs.debug("Quote for %s: %s"% (ticker,quote))
try:
last=float(last_str)
except ValueError:
self.logs.error("Malformed last for %s:%s"% (ticker,last_str))
return None
if last>0:
return last
else:
self.logs.error("Bad quote for: %s"% ticker)
return None
def get_order_url(self):
""" Gets TradeKing URL for placing orders"""
url_path="accounts/%s/orders"%TRADEKING_ACCOUNT_NUMBER
if not USE_REAL_MONEY:
url_path+="/preview"
return TRADEKING_API_URL % url_path
def get_quantity(self,ticker,budget):
""" Calculates quantity of stock based on current market price and a maximum budget"""
#Calculate quantity based on current price and budget
price=self.get_last_price(ticker)
if not price:
self.logs.error("Failed to determine price for: %s" %ticker)
return(None,None)
#use max number possible quantity within budget
quantity=int(budget // price)
self.logs.debug("Determined quantity %sfor %s at $%s within $%s." %(quantity,tiker,price,budget))
return (quantity, price)
def bull(self,ticker,budget):
""" Executes bullish strategy on specified stock within specified budget: Buy now at market rate and sell at market rate at close"""
#Calculate quantity
quantity,price=self.get_quantity(ticker,budget)
if not quantity:
self.logs.warn("Not trading without quantity.")
return False
#Buy stock now
buy_limit=self.get_buy_limit(price)
buy_fixml=self.fixml_buy_now(ticker,quantity,buy_limit)
if not self.make_order_request(buy_fixml):
return False
#sell stock at close
sell_limit=self.get_sell_limit(price)
sell_fixml=self.fixml_sell_eod(ticker,quantity,sell_limit)
# TODo: Do this by checking order status API and using retries with exponential backoff
#wait until previous order has been executed
return True
def bear(self,ticker,budget):
"""Executes bearish strategy on specified stock within specified budget: Sell short at market rate and buy to cover at market rate close"""
#Calculate quantity
quantity,price=self.get_quantity(ticker,budget)
if not quantity:
self.logs.warn("Not trading without quantity")
return False
#Short stock now
short_limit=self.get_sell_limit(price)
short_fixml=self.fixml_short_now(ticker,quantity,short_limit)
if not self.make_order_request(short_fixml):
return False
#Cover short at close
cover_limit=self.get_buy_limit(price)
cover_fixml=self.fixml_cover_eod(ticker, quantity ,cover_limit)
#TO Do: check order status API and use retries, exponential backoff
#wait until previous order has been executed
Timer(ORDER_DELAY_S,self.make_order_request,[cover_fixml]).start()
return True
def make_order_request(self,fixml):
""" Executes order defined by FIXML and verifies response"""
response=self.make_request(url=self.get_order_url(),method="POST",body=fixml,headers=FIXML_HEADERS)
if not response:
self.logs.error("No order response for: %s" % fixml)
return False
try:
order_response=response["response"]
error=order_response["error"]
except KeyError:
self.logs.error("Malformed order response: %s" % fixml)
return False
#Error field indicates whether order succeeded
error=order_response["error"]
if error!="Success":
self.logs.error("Error in order response: %s %s"% (error,order_response))
return False
return True
