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 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 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 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