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