def order_target_percent(asset,
percent,
style=OrderStyle.MarketOrder,
sec_type='STK',
trade_trace_fn=None):
if percent == 0:
Order.order_target(asset, 0, style, sec_type, trade_trace_fn)
else:
portfolio = API().get_portfolio_info()
current_percent = portfolio.get_percentage(asset)
order_cash = (percent -
current_percent) * portfolio.net_liquidation
message_tempalte = """percent=%s,
current_percent=%s,
net_liquidation=%s,
order_cash=%s,
available_funds=%s"""
message = message_tempalte % (
percent, current_percent, portfolio.net_liquidation,
order_cash, portfolio.available_funds)
Order.get_logger().info(message)
# if order_cash < portfolio.available_funds:
try:
market_price = API().get_market_price(asset)
except Exception:
from wrapi.data import Data
market_price = Data().current(asset)
amount = int(round(order_cash / market_price))
return Order.order(asset, amount, style, sec_type, trade_trace_fn)
class IBCurrent(AbstractCurrentDataProvider):
def __init__(self):
self.api = API()
def get_data_by_symbol(self, symbol):
price = self.api.get_market_price(symbol)
count = 0
for i in range(5):
if price < 0:
count += 1
if count <= 3:
time.sleep(3)
continue
else:
raise Exception(
'The price is negative for 3 times, price = %s' %
price)
else:
return price
def get_current_data(self, symbols):
try:
return map(self.get_data_by_symbol, symbols)
except Exception as e:
get_logger().error('Trace: ' + traceback.format_exc(), False)
get_logger().error('Error: get current price from IB failed:' +
str(e))
return None
def get_open_orders(asset=None, include_option=False):
orders = API().get_open_orders(include_option)
if asset:
orders = filter(lambda x: x[1] == asset, orders)
rows = map(lambda x: x[1:], orders)
orderids = map(lambda x: int(x[0]), orders)
fields = ['symbol', 'action', 'quantity']
return pd.DataFrame(rows, columns=fields, index=orderids)
def save_portfolio_info(strategy_name):
date = datetime.datetime.now(
tz=pytz.timezone('US/Eastern')).strftime('%Y-%m-%d')
dic = PortfolioDAO.read_portfolio_info(strategy_name)
dic[date] = API().get_portfolio_info().to_dict()
file_path = PathMgr.get_strategies_portfolio_file(strategy_name)
ensure_parent_dir_exists(file_path)
write_to_file(file_path, json.dumps(dic, indent=4, sort_keys=True))
def order_target(asset,
amount,
style=OrderStyle.MarketOrder,
sec_type='STK',
trade_trace_fn=None):
portfolio = API().get_portfolio_info()
delta_amount = amount - portfolio.positions[asset].amount
return Order.order(asset, delta_amount, style, sec_type,
trade_trace_fn)
def order(asset,
amount,
style=OrderStyle.MarketOrder,
sec_type='STK',
trade_trace_fn=None):
# if trade_trace_fn is not None:
# trade_trace_fn(asset, amount)
[order_type, price] = style
if amount > 0:
return API().order(asset, sec_type, order_type, amount, 'BUY',
price)
elif amount < 0:
return API().order(asset, sec_type, order_type, -amount, 'SELL',
price)
else:
pass
if trade_trace_fn is not None and amount != 0:
trade_trace_fn(asset, amount)
class IBProvider(AbstractHistoricalDataProvider):
def __init__(self):
self.api = API()
def history(self, symbol, field, window):
fields_dic = {'open': 1, 'close': 4, 'high': 2, 'low': 3,
'price': 4, 'unadj': 4}
results = self.api.get_historical_data(symbol, window, 'day')
return map(lambda x: [x[0], x[fields_dic[field]]], results)
def history_min(self, symbol, window):
days_window = window/390 + 1
records = self.api.get_historical_data(symbol, days_window, 'min')
results = []
for record in records[-window:]:
tradetime = record[0]
if tradetime.hour == 9 and tradetime.minute == 30 and tradetime.second == 0:
tradetime = datetime.datetime(tradetime.year, tradetime.month, tradetime.day, 9, 30, 1)
close = record[4]
results.append([tradetime, close])
return results
def set_stop_price(asset, stop_price):
quantity = API().get_portfolio_info().get_quantity(asset)
return Order.order_target(asset, -quantity,
OrderStyle.StopOrder(stop_price))
def cancel_order(order_id):
API().cancel_order(order_id)
def __init__(self):
self.api = API()
def portfolio(self):
return API().get_portfolio_info()