def collect_option_chains(universes=None,
conids=None,
infilepath_or_buffer=None):
"""
Collect option chains for underlying securities.
Note: option chains often consist of hundreds, sometimes thousands of
options per underlying security. Be aware that requesting option chains
for large universes of underlying securities, such as all stocks on the
NYSE, can take numerous hours to complete, add hundreds of thousands of
rows to the securities master database, increase the database file size
by several hundred megabytes, and potentially add latency to database
queries.
Parameters
----------
universes : list of str, optional
collect options for these universes of underlying securities
conids : list of int, optional
collect options for these underlying conids
infilepath_or_buffer : str or file-like object, optional
collect options for the conids in this file (specify '-' to read file
from stdin)
Returns
-------
dict
status message
"""
params = {}
if universes:
params["universes"] = universes
if conids:
params["conids"] = conids
if infilepath_or_buffer == "-":
response = houston.post("/master/options",
params=params,
data=to_bytes(sys.stdin))
elif infilepath_or_buffer and hasattr(infilepath_or_buffer, "read"):
if infilepath_or_buffer.seekable():
infilepath_or_buffer.seek(0)
response = houston.post("/master/options",
params=params,
data=to_bytes(infilepath_or_buffer))
elif infilepath_or_buffer:
with open(infilepath_or_buffer, "rb") as f:
response = houston.post("/master/options", params=params, data=f)
else:
response = houston.post("/master/options", params=params)
houston.raise_for_status_with_json(response)
return response.json()
def load_history_from_file(code, infilepath_or_buffer):
"""
Load market data from a CSV file into a history database.
Parameters
----------
code : str, required
the database code to load into
infilepath_or_buffer : str or file-like object
CSV file containing market data (specify '-' to read file from stdin)
Returns
-------
dict
status message
"""
url = "/history/{0}.csv".format(code)
# Loading large amounts of data can take awhile
timeout = 60 * 60
if infilepath_or_buffer == "-":
response = houston.patch(url,
data=to_bytes(sys.stdin),
timeout=timeout)
elif infilepath_or_buffer and hasattr(infilepath_or_buffer, "read"):
if infilepath_or_buffer.seekable():
infilepath_or_buffer.seek(0)
response = houston.patch(url,
data=to_bytes(infilepath_or_buffer),
timeout=timeout)
else:
with open(infilepath_or_buffer, "rb") as f:
response = houston.patch(url, data=f, timeout=timeout)
houston.raise_for_status_with_json(response)
return response.json()
def round_to_tick_sizes(infilepath_or_buffer, round_fields,
how=None, append_ticksize=False,
outfilepath_or_buffer=None):
"""
Round prices in a CSV file to valid tick sizes.
CSV should contain columns `ConId`, `Exchange`, and the columns to be rounded
(e.g. `LmtPrice`). Additional columns will be ignored and returned unchanged.
Parameters
----------
infilepath_or_buffer : str or file-like object, required
CSV file with prices to be rounded (specify '-' to read file from stdin)
round_fields : list of str, required
columns to be rounded
how : str, optional
which direction to round to. Possible choices: 'up', 'down', 'nearest'
(default is 'nearest')
append_ticksize : bool
append a column of tick sizes for each field to be rounded (default False)
outfilepath_or_buffer : str or file-like object
filepath to write the data to, or file-like object (defaults to stdout)
Returns
-------
None
"""
params = {}
if round_fields:
params["round_fields"] = round_fields
if how:
params["how"] = how
if append_ticksize:
params["append_ticksize"] = append_ticksize
url = "/master/ticksizes.csv"
if infilepath_or_buffer == "-":
# No-op if an empty file is passed on stdin
f = six.StringIO(sys.stdin.read())
if not f.getvalue():
return
response = houston.get(url, params=params, data=to_bytes(f))
elif infilepath_or_buffer and hasattr(infilepath_or_buffer, "read"):
if infilepath_or_buffer.seekable():
infilepath_or_buffer.seek(0)
response = houston.get(url, params=params, data=to_bytes(infilepath_or_buffer))
elif infilepath_or_buffer:
with open(infilepath_or_buffer, "rb") as f:
response = houston.get(url, params=params, data=f)
else:
raise ValueError("infilepath_or_buffer is required")
houston.raise_for_status_with_json(response)
filepath_or_buffer = outfilepath_or_buffer or sys.stdout
write_response_to_filepath_or_buffer(filepath_or_buffer, response)
def create_universe(code, infilepath_or_buffer=None, from_universes=None,
exclude_delisted=False, append=False, replace=False,
domain=None):
"""
Create a universe of securities.
Parameters
----------
code : str, required
the code to assign to the universe (lowercase alphanumerics and hyphens only)
infilepath_or_buffer : str or file-like object, optional
create the universe from the conids in this file (specify '-' to read file from stdin)
from_universes : list of str, optional
create the universe from these existing universes
exclude_delisted : bool
exclude delisted securities that would otherwise be included (default
is not to exclude them)
append : bool
append to universe if universe already exists (default False)
replace : bool
replace universe if universe already exists (default False)
domain : str, optional
create universe in this domain (default is 'main', which runs against
quantrocket.master.main.sqlite. Possible choices: main, sharadar)
Returns
-------
dict
status message
Examples
--------
Create a universe called 'nyse-stk' from a CSV file:
>>> create_universe("usa-stk", "nyse_securities.csv")
Create a universe from a DataFrame:
>>> import io
>>> f = io.StringIO()
>>> japan_securities.to_csv(f)
>>> create_universe("japan-stk", f)
"""
if append and replace:
raise ValueError("append and replace are mutually exclusive")
params = {}
if from_universes:
params["from_universes"] = from_universes
if exclude_delisted:
params["exclude_delisted"] = exclude_delisted
if replace:
params["replace"] = replace
url = "/master/{0}universes/{1}".format(
"{0}/".format(domain) if domain else "",
code)
if append:
method = "PATCH"
else:
method = "PUT"
if infilepath_or_buffer == "-":
response = houston.request(method, url, params=params, data=to_bytes(sys.stdin))
elif infilepath_or_buffer and hasattr(infilepath_or_buffer, "read"):
if infilepath_or_buffer.seekable():
infilepath_or_buffer.seek(0)
response = houston.request(method, url, params=params, data=to_bytes(infilepath_or_buffer))
elif infilepath_or_buffer:
with open(infilepath_or_buffer, "rb") as f:
response = houston.request(method, url, params=params, data=f)
else:
response = houston.request(method, url, params=params)
houston.raise_for_status_with_json(response)
return response.json()
def diff_securities(universes=None, conids=None, infilepath_or_buffer=None,
fields=None, delist_missing=False, delist_exchanges=None,
wait=False):
"""
Flag security details that have changed in IB's system since the time they
were last collected into the securities master database.
Diff can be run synchronously or asynchronously (asynchronous is the default
and is recommended if diffing more than a handful of securities).
Parameters
----------
universes : list of str, optional
limit to these universes
conids : list of int, optional
limit to these conids
infilepath_or_buffer : str or file-like object, optional
limit to the conids in this file (specify '-' to read file from stdin)
fields : list of str, optional
only diff these fields
delist_missing : bool
auto-delist securities that are no longer available from IB
delist_exchanges : list of str, optional
auto-delist securities that are associated with these exchanges
wait : bool
run the diff synchronously and return the diff (otherwise run
asynchronously and log the results, if any, to flightlog)
Returns
-------
dict
dict of conids and fields that have changed (if wait), or status message
"""
params = {}
if universes:
params["universes"] = universes
if conids:
params["conids"] = conids
if fields:
params["fields"] = fields
if delist_missing:
params["delist_missing"] = delist_missing
if delist_exchanges:
params["delist_exchanges"] = delist_exchanges
if wait:
params["wait"] = wait
# if run synchronously use a high timeout
timeout = 60*60*10 if wait else None
if infilepath_or_buffer == "-":
response = houston.get("/master/diff", params=params, data=to_bytes(sys.stdin), timeout=timeout)
elif infilepath_or_buffer and hasattr(infilepath_or_buffer, "read"):
if infilepath_or_buffer.seekable():
infilepath_or_buffer.seek(0)
response = houston.get("/master/diff", params=params, data=to_bytes(infilepath_or_buffer), timeout=timeout)
elif infilepath_or_buffer:
with open(infilepath_or_buffer, "rb") as f:
response = houston.get("/master/diff", params=params, data=f, timeout=timeout)
else:
response = houston.get("/master/diff", params=params, timeout=timeout)
houston.raise_for_status_with_json(response)
return response.json()
def create_db(code, universes=None, conids=None, start_date=None, end_date=None,
vendor=None, bar_size=None, bar_type=None, outside_rth=False,
primary_exchange=False, times=None, between_times=None,
shard=None, no_config=False, config_filepath_or_buffer=None):
"""
Create a new history database.
Parameters
----------
code : str, required
the code to assign to the database (lowercase alphanumerics and hyphens only)
universes : list of str
include these universes
conids : list of int
include these conids
start_date : str (YYYY-MM-DD), optional
collect history back to this start date (default is to collect as far back as data
is available)
end_date : str (YYYY-MM-DD), optional
collect history up to this end date (default is to collect up to the present)
vendor : str, optional
the vendor to collect data from (default 'ib'. Possible choices: ib, sharadar)
bar_size : str, required for vendor ib
the bar size to collect. Possible choices:
"1 secs", "5 secs", "10 secs", "15 secs", "30 secs",
"1 min", "2 mins", "3 mins", "5 mins", "10 mins", "15 mins", "20 mins", "30 mins",
"1 hour", "2 hours", "3 hours", "4 hours", "8 hours",
"1 day",
"1 week",
"1 month"
bar_type : str, optional
the bar type to collect (if not specified, defaults to MIDPOINT for forex and
TRADES for everything else). Possible choices:
"TRADES",
"ADJUSTED_LAST",
"MIDPOINT",
"BID",
"ASK",
"BID_ASK",
"HISTORICAL_VOLATILITY",
"OPTION_IMPLIED_VOLATILITY"
outside_rth : bool
include data from outside regular trading hours (default is to limit to regular
trading hours)
primary_exchange : bool
limit to data from the primary exchange (default False)
times : list of str (HH:MM:SS), optional
limit to these times (refers to the bar's start time; mutually exclusive
with `between_times`)
between_times : list of str (HH:MM:SS), optional
limit to times between these two times (refers to the bar's start time;
mutually exclusive with `times`)
shard : str, optional
whether and how to shard the database, i.e. break it into smaller pieces.
Required for intraday databases. Possible choices are `year` (separate
database for each year), `time` (separate database for each bar time),
`conid` (separate database for each security), `conid,time` (duplicate copies
of database, one sharded by conid and the other by time), or `off` (no
sharding). See http://qrok.it/h/shard for more help.
no_config : bool
create a database with no config (data can be loaded manually instead of collected
from a vendor)
config_filepath_or_buffer : str or file-like object, optional
a YAML config file defining the historical data requirements (specify '-' to read file from stdin)
Returns
-------
dict
status message
"""
params = {}
if universes:
params["universes"] = universes
if conids:
params["conids"] = conids
if start_date:
params["start_date"] = start_date
if end_date:
params["end_date"] = end_date
if vendor:
params["vendor"] = vendor
if bar_size:
params["bar_size"] = bar_size
if bar_type:
params["bar_type"] = bar_type
if outside_rth:
params["outside_rth"] = outside_rth
if primary_exchange:
params["primary_exchange"] = primary_exchange
if times:
params["times"] = times
if between_times:
params["between_times"] = between_times
if shard:
params["shard"] = shard
if no_config:
params["no_config"] = True
if config_filepath_or_buffer == "-":
response = houston.put("/history/databases/{0}".format(code), params=params,
data=to_bytes(sys.stdin))
elif config_filepath_or_buffer and hasattr(config_filepath_or_buffer, "read"):
response = houston.put("/history/databases/{0}".format(code), params=params,
data=to_bytes(config_filepath_or_buffer))
elif config_filepath_or_buffer:
with open(config_filepath_or_buffer, "rb") as f:
response = houston.put("/history/databases/{0}".format(code), params=params, data=f)
else:
response = houston.put("/history/databases/{0}".format(code), params=params)
houston.raise_for_status_with_json(response)
return response.json()
def place_orders(orders=None, infilepath_or_buffer=None):
"""
Place one or more orders.
Returns a list of order IDs, which can be used to cancel the orders or check
their status.
Parameters
----------
orders : list of dict of PARAM:VALUE, optional
a list of one or more orders, where each order is a dict specifying the
order parameters (see examples)
infilepath_or_buffer : str or file-like object, optional
place orders from this CSV or JSON file (specify '-' to read file
from stdin). Mutually exclusive with `orders` argument.
Returns
-------
list
order IDs
Examples
--------
>>> orders = []
>>> order1 = {
'ConId':123456,
'Action':'BUY',
'Exchange':'SMART',
'TotalQuantity':100,
'OrderType':'MKT',
'Tif':'Day',
'Account':'DU12345',
'OrderRef':'my-strategy'
}
>>> orders.append(order1)
>>> order_ids = place_orders(orders)
"""
if orders and infilepath_or_buffer:
raise ValueError(
"orders and infilepath_or_buffer are mutually exclusive")
url = "/blotter/orders"
if orders:
response = houston.post(url, json=orders)
elif infilepath_or_buffer == "-":
response = houston.post(url, data=to_bytes(sys.stdin))
elif infilepath_or_buffer and hasattr(infilepath_or_buffer, "read"):
if infilepath_or_buffer.seekable():
infilepath_or_buffer.seek(0)
response = houston.post(url, data=to_bytes(infilepath_or_buffer))
elif infilepath_or_buffer:
with open(infilepath_or_buffer, "rb") as f:
response = houston.post(url, data=f)
else:
response = houston.post(url)
houston.raise_for_status_with_json(response)
return response.json()
def create_universe(code, infilepath_or_buffer=None, from_universes=None,
exclude_delisted=False, append=False, replace=False):
"""
Create a universe of securities.
Parameters
----------
code : str, required
the code to assign to the universe (lowercase alphanumerics and hyphens only)
infilepath_or_buffer : str or file-like object, optional
create the universe from the conids in this file (specify '-' to read file from stdin)
from_universes : list of str, optional
create the universe from these existing universes
exclude_delisted : bool
exclude delisted securities that would otherwise be included (default is not to exclude them)
append : bool
append to universe if universe already exists (default False)
replace : bool
replace universe if universe already exists (default False)
Returns
-------
dict
status message
"""
if append and replace:
raise ValueError("append and replace are mutually exclusive")
params = {}
if from_universes:
params["from_universes"] = from_universes
if exclude_delisted:
params["exclude_delisted"] = exclude_delisted
if replace:
params["replace"] = replace
url = "/master/universes/{0}".format(code)
if append:
method = "PATCH"
else:
method = "PUT"
if infilepath_or_buffer == "-":
response = houston.request(method, url, params=params, data=to_bytes(sys.stdin))
elif infilepath_or_buffer and hasattr(infilepath_or_buffer, "read"):
if infilepath_or_buffer.seekable():
infilepath_or_buffer.seek(0)
response = houston.request(method, url, params=params, data=to_bytes(infilepath_or_buffer))
elif infilepath_or_buffer:
with open(infilepath_or_buffer, "rb") as f:
response = houston.request(method, url, params=params, data=f)
else:
response = houston.request(method, url, params=params)
houston.raise_for_status_with_json(response)
return response.json()
def create_db(code, universes=None, start_date=None, end_date=None,
vendor=None, bar_size=None, bar_type=None, outside_rth=False,
primary_exchange=False, times=None,
no_config=False, config_filepath_or_buffer=None):
"""
Create a new history database.
Parameters
----------
code : str, required
the code to assign to the database (lowercase alphanumerics and hyphens only)
universes : list of str
include these universes
start_date : str (YYYY-MM-DD), optional
fetch history back to this start date (default is to fetch as far back as data
is available)
end_date : str (YYYY-MM-DD), optional
fetch history up to this end date (default is to fetch up to the present)
vendor : str, optional
the vendor to fetch data from (defaults to 'ib' which is currently the only
supported vendor)
bar_size : str, required for vendor ib
the bar size to fetch. Possible choices:
"1 secs", "5 secs", "10 secs", "15 secs", "30 secs",
"1 min", "2 mins", "3 mins", "5 mins", "10 mins", "15 mins", "20 mins", "30 mins",
"1 hour", "2 hours", "3 hours", "4 hours", "8 hours",
"1 day",
"1 week",
"1 month"
bar_type : str, optional
the bar type to fetch (if not specified, defaults to MIDPOINT for forex and
TRADES for everything else). Possible choices:
"TRADES",
"ADJUSTED_LAST",
"MIDPOINT",
"BID",
"ASK",
"BID_ASK",
"HISTORICAL_VOLATILITY",
"OPTION_IMPLIED_VOLATILITY"
outside_rth : bool
include data from outside regular trading hours (default is to limit to regular
trading hours)
primary_exchange : bool
limit to data from the primary exchange (default False)
times : list of str (HH:MM:SS), optional
limit to these times
no_config : bool
create a database with no config (data can be loaded manually instead of fetched
from a vendor)
config_filepath_or_buffer : str or file-like object, optional
a YAML config file defining the historical data requirements (specify '-' to read file from stdin)
Returns
-------
dict
status message
"""
params = {}
if universes:
params["universes"] = universes
if start_date:
params["start_date"] = start_date
if end_date:
params["end_date"] = end_date
if vendor:
params["vendor"] = vendor
if bar_size:
params["bar_size"] = bar_size
if bar_type:
params["bar_type"] = bar_type
if outside_rth:
params["outside_rth"] = outside_rth
if primary_exchange:
params["primary_exchange"] = primary_exchange
if times:
params["times"] = times
if no_config:
params["no_config"] = True
if config_filepath_or_buffer == "-":
response = houston.put("/history/databases/{0}".format(code), params=params,
data=to_bytes(sys.stdin))
elif config_filepath_or_buffer and hasattr(config_filepath_or_buffer, "read"):
response = houston.put("/history/databases/{0}".format(code), params=params,
data=to_bytes(config_filepath_or_buffer))
elif config_filepath_or_buffer:
with open(config_filepath_or_buffer, "rb") as f:
response = houston.put("/history/databases/{0}".format(code), params=params, data=f)
else:
response = houston.put("/history/databases/{0}".format(code), params=params)
houston.raise_for_status_with_json(response)
return response.json()
