def login_robinhood(path_to_credentials):
from fast_arrow import Client
credentials = open(path_to_credentials, 'r').read()
credentials = credentials.split("\n")
client = Client(username=credentials[0], password=credentials[1])
print(client.authenticate())
return client
def __init__(self, username, password):
"""The Biggest Challenge to Using the Robinhood Data is figuring out the client
authentication. They use Multifactor authentication, so you have to figure out a way
to add your credentials. The way I have it set up is that I get an email, adn the code
automatically parses my email to get the code."""
self.client = Client(username=username, password=password)
self.client.authenticate() # this part can use some finagling.
class Robinhood:
def __init__(self):
username, password, device_token = self.setup()
self.username = username
self.password = password
self.device_token = device_token
def setup(self):
config_path = os.path.join(os.path.dirname(__file__), '../config.local.json')
username = ''
password = ''
device_token = None
with open(config_path) as config_file:
config = json.load(config_file)
username = config['robinhood']['username']
password = config['robinhood']['password']
device_token = config['robinhood']['device-token']
return (username, password, device_token)
def login(self):
self.client = Client(
username=self.username,
password=self.password,
device_token=self.device_token)
self.result = self.client.authenticate()
self.user = User.fetch(self.client)
print("Authenticated successfully = {}".format(self.result))
print("Account Url = {}".format(self.client.account_url))
print("Account Id = {}".format(self.client.account_id))
print("Username = {}".format(self.user["username"]))
print()
# Set client to legacy version for further use
auth_data = self.client.gen_credentials()
self.client = ClientLegacy(auth_data)
return self.client
def get_quote(self, symbol):
return StockMarketdata.quote_by_symbol(self.client, symbol)
def get_option_chain(self, symbol, stock):
stock_id = stock["instrument"].split("/")[-2]
return OptionChain.fetch(self.client, stock_id, symbol)
def get_next_3_exp_options(self, option_chain):
option_chain_id = option_chain["id"]
expiration_dates = option_chain['expiration_dates']
next_3_expiration_dates = expiration_dates[0:3]
ops = Option.in_chain(self.client, option_chain_id, expiration_dates=next_3_expiration_dates)
ops = Option.mergein_marketdata_list(client, ops)
return ops
def login(self):
self.client = Client(
username=self.username,
password=self.password,
device_token=self.device_token)
self.result = self.client.authenticate()
self.user = User.fetch(self.client)
print("Authenticated successfully = {}".format(self.result))
print("Account Url = {}".format(self.client.account_url))
print("Account Id = {}".format(self.client.account_id))
print("Username = {}".format(self.user["username"]))
print()
# Set client to legacy version for further use
auth_data = self.client.gen_credentials()
self.client = ClientLegacy(auth_data)
return self.client
import configparser
from fast_arrow import Client, OptionOrder
print("----- running {}".format(__file__))
config = configparser.ConfigParser()
config.read('config.debug.ini')
#
# initialize fast_arrow client and authenticate
#
client = Client(username=config['account']['username'],
password=config['account']['password'])
client.authenticate()
#
# fetch option orders
#
option_orders_all = OptionOrder.all(client)
#
# in case you have lots, only use first 25
# (unroll process fetches contract data for each leg)
#
option_orders = option_orders_all[0:25]
#
# unroll option orders ... ie, break each option leg into its own row
# this is helpful when doing detailed P/L reporting
#
from datatype_tools.lib import *
from print_tools.printer import Printer
from fast_arrow import Client, OptionChain, Option, OptionPosition, OptionOrder
#: Login
p = Printer()
client = Client()
client.authenticate()
#: Get Positions
positions = OptionPosition.all(client)
positions = list(filter(lambda p: float(p["quantity"]) > 0.0, positions))
if (len(positions) > 0):
positions = OptionPosition.mergein_marketdata_list(client, positions)
positions = OptionPosition.mergein_instrumentdata_list(client, positions)
positions = OptionPosition.mergein_orderdata_list(client, positions)
#: Get Most Recent Order
symbol = positions[0]['chain_symbol']
strat = positions[0]['option_type']
effect = positions[0]['type']
buy_price = positions[0]['average_price']
bid_price = positions[0]['bid_price']
expiration_date = positions[0]['expiration_date']
quantity = positions[0]['quantity']
url = positions[0]['instrument']
def _init_client(username, password):
client = Client(username=username, password=password)
client.authenticate()
return client
def test_init(self):
auth_data = self.example_auth_data()
Client(auth_data)
print("----- running {}".format(__file__))
#
# get the authentication configs
#
config_file = "config.debug.ini"
config = configparser.ConfigParser()
config.read(config_file)
username = config['account']['username']
password = config['account']['password']
#
# initialize and authenticate Client
#
client = Client(username=username, password=password)
client.authenticate()
#
# fetch spy options
#
symbol = "SPY"
stock = Stock.fetch(client, symbol)
stock = Stock.mergein_marketdata_list(client, [stock])[0]
oc = OptionChain.fetch(client, stock["id"], symbol)
ed = oc['expiration_dates'][0]
ops = Option.in_chain(client, oc["id"], expiration_dates=[ed])
#
# enrich options with market data
def gen_client():
return Client()
class Robinhood_Data:
"""This code uses fast-arrow, a library developed by
Weston Platter. It's excellent, and it showcases the power of
the Robinhood API. You can find the API here...
https://github.com/westonplatter/fast_arrow.
While the brokerage has its limits, it's great for real time Options Market
Analyses."""
def __init__(self, username, password):
"""The Biggest Challenge to Using the Robinhood Data is figuring out the client
authentication. They use Multifactor authentication, so you have to figure out a way
to add your credentials. The way I have it set up is that I get an email, adn the code
automatically parses my email to get the code."""
self.client = Client(username=username, password=password)
self.client.authenticate() # this part can use some finagling.
def get_spot_price(self, symbol):
"""Returns a dictionary of data about the spot price,
which includes bid, ask, bid size, ask size, as well as some api identification"""
stock1 = Stock.fetch(self.client, symbol)
stock = StockMarketdata.quote_by_instrument(self.client,
_id=stock1['id'])
return stock
def _process_spot_price(self, spot_price_object):
"""returns mid point price"""
return (float(spot_price_object['bid_price']) +
float(spot_price_object['ask_price'])) / 2
def __convert_to_float(self, x):
try:
return np.float(x)
except:
return x
def get_options_robinhood(self, symbol, **exp):
"""Get Robinhood Options Chains for Puts and Calls.
The code returns three objects. This code returns two pandas dataframes
The first is Calls, the Second is Puts. The final output is the spot price.
"""
try:
stock = Stock.fetch(self.client, symbol)
stock_id = stock["id"]
option_chain = OptionChain.fetch(self.client,
stock_id,
symbol=symbol)
eds = option_chain['expiration_dates']
oc_id = option_chain["id"]
spot = self.get_spot_price(symbol)
spot_price = self._process_spot_price(spot)
if exp:
if exp['exp'] not in eds:
print(
'Expiry not a Valid Expiration,Here are the valid Expirations \n'
)
print(eds)
return np.nan, np.nan, np.nan
expiry = exp['exp']
eds = [expiry]
else:
print(
'Expiry not a Valid Expiration,Here are the valid Expirations \n'
)
print(eds)
return np.nan, np.nan, np.nan
ops = Option.in_chain(self.client, oc_id, expiration_dates=eds)
ops = Option.mergein_marketdata_list(self.client, ops)
df = pd.DataFrame(ops)
df.index = np.arange(0, len(df))
#calls = df.loc[df.type=='call']
#calls = calls.sort_index()
#puts = df.loc[df.type=='put']
#puts = puts.sort_index()
df['spot_price'] = spot_price
#puts['spot_price'] = spot_price
df = df.applymap(self.__convert_to_float)
df['expiration_date'] = pd.to_datetime(
df['expiration_date'].values)
#puts = puts.applymap(self.__convert_to_float)
return df.fillna(0)
except:
return pd.DataFrame()
def get_all_options_robinhood(self, symbol):
"""Here, we use a library called 'DASK' to parallelize our code to fetch the data. We can be clever
and fetch it all at once, to HOPEFULLY, speed up data retrieval for our larger datasets,
like SPY and AMZN, to name a couple.
from dask import delayed"""
df_list = []
stock = Stock.fetch(self.client, symbol)
stock_id = stock["id"]
expiries = OptionChain.fetch(self.client, stock_id,
symbol=symbol)['expiration_dates']
for expiration_date in expiries:
#print(expiration_date)
y = delayed(self.get_options_robinhood)(symbol,
exp=expiration_date)
df_list.append(y)
ans = delayed(pd.concat)(df_list)
df = ans.compute()
return df.loc[df.type == 'call'], df.loc[df.type ==
'put'], df.spot_price.iloc[0]
from fast_arrow import (Client, StockMarketdata)
#
# initialize. Don't need to authenticate for stock data.
#
client = Client()
#
# fetch price quote data
#
symbol = "SQ"
stock = StockMarketdata.quote_by_symbol(client, symbol)
print("{} ask_price = {}".format(stock['symbol'], stock['ask_price']))
print("{} bid_price = {}".format(stock['symbol'], stock['bid_price']))
def test_current_auth_data(self):
auth_data = self.example_auth_data()
client = Client(auth_data)
ad = client.current_auth_data()
for key in auth_data.keys():
assert (auth_data[key] == ad[key])
def test_init_validates_auth_data(self):
auth_data = self.example_auth_data()
del auth_data['account_id']
with self.assertRaises(AuthDataError):
Client(auth_data)
import configparser
from fast_arrow import Client
from fast_arrow import Portfolio
#
# get the authentication configs
#
config_file = "config.debug.ini"
config = configparser.ConfigParser()
config.read(config_file)
username = config['account']['username']
password = config['account']['password']
account = config['account']['account']
client = Client(username=username, password=password)
result = client.authenticate()
span = "year"
bounds = "regular"
portfolio_historicals = Portfolio.historical(client, account, span, bounds)
ehs = portfolio_historicals["equity_historicals"]
begins_at = ehs[-1]["begins_at"]
ends_at = ehs[0]["begins_at"]
print(ehs[0].keys())
print("Fetched portfolio data between {} and {}".format(begins_at, ends_at))
import configparser
from fast_arrow import Client
from fast_arrow.resources.user import User
print("----- running {}".format(__file__))
#
# get the authentication configs
#
config_file = "config.debug.ini"
config = configparser.ConfigParser()
config.read(config_file)
username = config['account']['username']
password = config['account']['password']
client = Client(username=username, password=password)
result = client.authenticate()
print("Authenticated successfully = {}".format(result))
print("Account Url = {}".format(client.account_url))
print("Account Id = {}".format(client.account_id))
user = User.fetch(client)
print("Username = {}".format(user["username"]))
result = client.relogin_oauth2()
print("Re-Authenticated with refresh_token successfully = {}".format(result))
result = client.logout_oauth2()
print("Logged out successfully = {}".format(result))
def initialize(self) -> None:
'''
Initializes the client by authenticating against the Robinhood exchange.
'''
if self.client is None:
self.client = Client(self.__gen_credentials())
def gen_client():
auth_data = gen_auth_data()
client = Client(auth_data)
return client
Option,
)
print("----- running {}".format(__file__))
#
# get auth_data (see https://github.com/westonplatter/fast_arrow_auth)
#
with open("fast_arrow_auth.json") as f:
auth_data = json.loads(f.read())
#
# initialize client with auth_data
#
client = Client(auth_data)
#
# fetch the stock info for TLT
#
symbol = "TLT"
md = StockMarketdata.quote_by_symbol(client, symbol)
#
# get the TLT option chain info
#
stock_id = md["instrument"].split("/")[-2]
option_chain = OptionChain.fetch(client, stock_id, symbol)
option_chain_id = option_chain["id"]
import json
from fast_arrow import Client
from fast_arrow.resources.user import User
print("----- running {}".format(__file__))
#
# get auth_data (see https://github.com/westonplatter/fast_arrow_auth)
#
with open("fast_arrow_auth.json") as f:
auth_data = json.loads(f.read())
#
# initialize client with auth_data
#
client = Client(auth_data)
print("Account Id = {}".format(client.account_id))
user = User.fetch(client)
print("Username = {}".format(user["username"]))
result = client.relogin_oauth2()
print("Re-Authenticated with refresh_token successfully = {}".format(result))
refreshed_auth_data = client.current_auth_data()
filename = "fast_arrow_auth.json"
with open(filename, "w") as f:
f.write(json.dumps(refreshed_auth_data, indent=4))
