def __init__(
self,
starting_cash,
period_open=None,
period_close=None,
keep_transactions=True,
keep_orders=False,
serialize_positions=True):
self.period_open = period_open
self.period_close = period_close
self.ending_value = 0.0
self.period_cash_flow = 0.0
self.pnl = 0.0
# sid => position object
self.positions = positiondict()
self.ending_cash = starting_cash
# rollover initializes a number of self's attributes:
self.rollover()
self.keep_transactions = keep_transactions
self.keep_orders = keep_orders
# Arrays for quick calculations of positions value
self._position_amounts = pd.Series()
self._position_last_sale_prices = pd.Series()
self.calculate_performance()
# An object to recycle via assigning new values
# when returning portfolio information.
# So as not to avoid creating a new object for each event
self._portfolio_store = zp.Portfolio()
self._positions_store = zp.Positions()
self.serialize_positions = serialize_positions
def positions(self):
z_positions = zp.Positions()
positions = self._api.list_positions()
position_map = {}
symbols = []
for pos in positions:
symbol = pos.symbol
try:
z_position = zp.Position(symbol_lookup(symbol))
except SymbolNotFound:
continue
z_position.amount = pos.qty
z_position.cost_basis = float(pos.cost_basis)
z_position.last_sale_price = None
z_position.last_sale_date = None
z_positions[symbol_lookup(symbol)] = z_position
symbols.append(symbol)
position_map[symbol] = z_position
quotes = self._api.list_quotes(symbols)
for quote in quotes:
price = quote.last
dt = quote.last_timestamp
z_position = position_map[quote.symbol]
z_position.last_sale_price = float(price)
z_position.last_sale_date = dt
return z_positions
def __setstate__(self, state):
OLDEST_SUPPORTED_STATE = 3
version = state.pop(VERSION_LABEL)
if version < OLDEST_SUPPORTED_STATE:
raise BaseException("PositionTracker saved state is too old.")
self.asset_finder = state['asset_finder']
self.positions = positiondict()
# note that positions_store is temporary and gets regened from
# .positions
self._positions_store = zp.Positions()
self._unpaid_dividends = state['unpaid_dividends']
self._auto_close_position_sids = state['auto_close_position_sids']
# Arrays for quick calculations of positions value
self._position_amounts = OrderedDict()
self._position_last_sale_prices = OrderedDict()
self._position_value_multipliers = OrderedDict()
self._position_exposure_multipliers = OrderedDict()
self._position_payout_multipliers = OrderedDict()
# Update positions is called without a finder
self.update_positions(state['positions'])
def positions(self):
z_positions = zp.Positions()
positions = self.api_client.Position.Position_get().result()[0][0]
position_map = {}
symbols = []
for pos in positions:
symbol = pos['symbol']
try:
z_position = zp.Position(symbol_lookup(symbol))
except SymbolNotFound:
continue
z_position.amount = pos['currentQty']
z_position.cost_basis = float(pos['currentCost'])
z_position.last_sale_price = None
z_position.last_sale_date = None
z_positions[symbol_lookup(symbol)] = z_position
symbols.append(symbol)
position_map[symbol] = z_position
quotes = self.ws_client.recent_trades()
for quote in quotes:
if quote['symbol'] != 'XBTUSD':
continue
price = quote['price']
dt = quote['timestamp']
z_position = position_map[quote['symbol']]
z_position.last_sale_price = float(price)
z_position.last_sale_date = dt
return z_positions
def positions(self):
curr_pos = self.get_latest_positions()
z_positions = zp.Positions()
# TODO: check/test this for loop
for index, symbol in curr_pos['holding_name'].iteritems():
vb_position = curr_pos[curr_pos['holding_name'] == symbol]
try:
z_position = zp.Position(symbol_lookup(symbol))
except SymbolNotFound:
# The symbol might not have been ingested to the db therefore
# it needs to be skipped.
continue
# Amount = quantity
z_position.amount = int(vb_position.quantity)
z_position.cost_basis = float(vb_position.buy_price)
# Check if symbol exists in bars df
if symbol in self._tws.bars:
z_position.last_sale_price = \
float(self._tws.bars[symbol].last_trade_price.iloc[-1])
z_position.last_sale_date = \
self._tws.bars[symbol].index.values[-1]
else:
z_position.last_sale_price = None
z_position.last_sale_date = None
z_positions[symbol_lookup(symbol)] = z_position
return z_positions
def __init__(self, data_frequency):
# asset => position object
self.positions = positiondict()
self._unpaid_dividends = {}
self._unpaid_stock_dividends = {}
self._positions_store = zp.Positions()
self.data_frequency = data_frequency
def __init__(self):
# sid => position object
self.positions = positiondict()
# Arrays for quick calculations of positions value
self._position_amounts = OrderedDict()
self._position_last_sale_prices = OrderedDict()
self._unpaid_dividends = pd.DataFrame(
columns=zp.DIVIDEND_PAYMENT_FIELDS, )
self._positions_store = zp.Positions()
def __init__(self, asset_finder):
self.asset_finder = asset_finder
# sid => position object
self.positions = positiondict()
# Arrays for quick calculations of positions value
self._position_value_multipliers = OrderedDict()
self._position_exposure_multipliers = OrderedDict()
self._unpaid_dividends = pd.DataFrame(
columns=zp.DIVIDEND_PAYMENT_FIELDS, )
self._positions_store = zp.Positions()
def __init__(self, data_frequency):
self.positions = OrderedDict()
self._unpaid_dividends = {}
self._unpaid_stock_dividends = {}
self._positions_store = zp.Positions()
self.data_frequency = data_frequency
# cache the stats until something alters our positions
self._dirty_stats = True
self._stats = PositionStats.new()
def __init__(self, asset_finder, data_frequency):
self.asset_finder = asset_finder
# sid => position object
self.positions = positiondict()
# Arrays for quick calculations of positions value
self._position_value_multipliers = OrderedDict()
self._position_exposure_multipliers = OrderedDict()
self._unpaid_dividends = {}
self._unpaid_stock_dividends = {}
self._positions_store = zp.Positions()
self.data_frequency = data_frequency
def positions(self):
now = datetime.datetime.now()
z_positions = protocol.Positions()
for row in self._client.query_data(SHARES).iteritems():
sid = row["证券代码"].values[0]
available = row["可用数量"].values[0]
z_position = protocol.Position(symbol(sid))
z_position.amount = row["证券数量"].values[0]
z_position.cost_basis = row["成本价"].values[0]
z_position.last_sale_price = row["当前价"].values[0]
z_position.last_sale_date = now
z_positions[symbol(sid)] = z_position
return z_positions
def __init__(self, asset_finder):
self.asset_finder = asset_finder
# sid => position object
self.positions = positiondict()
# Arrays for quick calculations of positions value
self._position_value_multipliers = OrderedDict()
self._position_exposure_multipliers = OrderedDict()
self._unpaid_dividends = pd.DataFrame(
columns=zp.DIVIDEND_PAYMENT_FIELDS, )
self._positions_store = zp.Positions()
# Dict, keyed on dates, that contains lists of close position events
# for any Assets in this tracker's positions
self._auto_close_position_sids = {}
def __init__(self, data_frequency):
self.positions = OrderedDict()
# self._unpaid_dividends = {}
self._lots_store = set()
self._unpaid_stock_dividends = {}
self._positions_store = zp.Positions()
self.data_frequency = data_frequency
# cache the stats until something alters our positions
self._dirty_stats = True
self._stats = PositionStats.new()
# pnl collected from closing out individual lots
self.pnl_realized = PnlRealized()
def positions(self):
now = datetime.datetime.now()
z_positions = protocol.Positions()
for pos in self._shipane_client.positions():
if isinstance(pos, list):
pos = TdxPosition(*pos)
sid = pos.sid
available = pos.available
z_position = protocol.Position(symbol(sid))
z_position.amount = pos.amount
z_position.cost_basis = pos.cost_basis
z_position.last_sale_price = pos.last_sale_price
z_position.last_sale_date = now
z_positions[symbol(sid)] = z_position
return z_positions
def positions(self):
z_positions = zp.Positions()
for symbol in self._tws.positions:
ib_position = self._tws.positions[symbol]
try:
z_position = zp.Position(symbol_lookup(symbol))
except SymbolNotFound:
log.warn("Symbol {} not found in the data base.", symbol)
continue
z_position.amount = int(ib_position.position)
z_position.cost_basis = float(ib_position.market_price)
z_position.last_sale_price = None # TODO(tibor): Fill from state
z_position.last_sale_date = None # TODO(tibor): Fill from state
z_positions[symbol_lookup(symbol)] = z_position
return z_positions
def positions(self):
z_positions = zp.Positions()
for symbol in self._tws.positions:
ib_position = self._tws.positions[symbol]
try:
z_position = zp.Position(symbol_lookup(symbol))
except SymbolNotFound:
# The symbol might not have been ingested to the db therefore
# it needs to be skipped.
continue
z_position.amount = int(ib_position.position)
z_position.cost_basis = float(ib_position.market_price)
z_position.last_sale_price = None # TODO(tibor): Fill from state
z_position.last_sale_date = None # TODO(tibor): Fill from state
z_positions[symbol_lookup(symbol)] = z_position
return z_positions
def __init__(self, asset_finder, data_portal, data_frequency):
self.asset_finder = asset_finder
# FIXME really want to avoid storing a data portal here,
# but the path to get to maybe_create_close_position_transaction
# is long and tortuous
self._data_portal = data_portal
# sid => position object
self.positions = positiondict()
# Arrays for quick calculations of positions value
self._position_value_multipliers = OrderedDict()
self._position_exposure_multipliers = OrderedDict()
self._unpaid_dividends = {}
self._unpaid_stock_dividends = {}
self._positions_store = zp.Positions()
self.data_frequency = data_frequency
def __setstate__(self, state):
OLDEST_SUPPORTED_STATE = 1
version = state.pop(VERSION_LABEL)
if version < OLDEST_SUPPORTED_STATE:
raise BaseException("PositionTracker saved state is too old.")
self.positions = positiondict()
# note that positions_store is temporary and gets regened from
# .positions
self._positions_store = zp.Positions()
self._unpaid_dividends = state['unpaid_dividends']
# Arrays for quick calculations of positions value
self._position_amounts = OrderedDict()
self._position_last_sale_prices = OrderedDict()
self.update_positions(state['positions'])
def __init__(self,
starting_cash,
period_open=None,
period_close=None,
keep_transactions=True,
keep_orders=False,
serialize_positions=True):
self.period_open = period_open
self.period_close = period_close
self.ending_value = 0.0
self.period_cash_flow = 0.0
self.pnl = 0.0
# sid => position object
self.positions = positiondict()
self.starting_value = 0.0
# cash balance at start of period
self.starting_cash = starting_cash
self.ending_cash = starting_cash
self.keep_transactions = keep_transactions
self.processed_transactions = defaultdict(list)
self.keep_orders = keep_orders
self.orders_by_modified = defaultdict(list)
self.orders_by_id = OrderedDict()
self.cumulative_capital_used = 0.0
self.max_capital_used = 0.0
self.max_leverage = 0.0
# Maps position to following array indexes
self._position_index_map = {}
# Arrays for quick calculations of positions value
self._position_amounts = np.array([])
self._position_last_sale_prices = np.array([])
self.calculate_performance()
# An object to recycle via assigning new values
# when returning portfolio information.
# So as not to avoid creating a new object for each event
self._portfolio_store = zp.Portfolio()
self._positions_store = zp.Positions()
self.serialize_positions = serialize_positions
def _get_positions_from_broker(self):
"""
get the positions from the broker and update zipline objects ( the ledger )
should be used once at startup and once every time we want to refresh the positions array
"""
cur_pos_in_tracker = self.metrics_tracker.positions
for ib_symbol in self._tws.ib_positions:
ib_position = self._tws.ib_positions[ib_symbol]
equity = self._safe_symbol_lookup(ib_symbol)
if not equity:
log.warning(
'Wanted to subscribe to %s, but this asset is probably not ingested'
% ib_symbol)
continue
zp_position = zp.Position(zp.InnerPosition(equity))
editable_position = MutableView(zp_position)
editable_position._underlying_position.amount = int(
ib_position.position)
editable_position._underlying_position.cost_basis = float(
ib_position.average_cost)
editable_position._underlying_position.last_sale_price = ib_position.market_price
last_close = self.metrics_tracker._trading_calendar.session_close(
self.metrics_tracker._last_session)
editable_position._underlying_position.last_sale_date = last_close
self.metrics_tracker.update_position(
zp_position.asset,
amount=zp_position.amount,
last_sale_price=zp_position.last_sale_price,
last_sale_date=zp_position.last_sale_date,
cost_basis=zp_position.cost_basis)
for asset in cur_pos_in_tracker:
ib_symbol = self._asset_symbol(asset)
if ib_symbol not in self._tws.ib_positions:
# deleting object from the metrcs_tracker as its not in the portfolio
self.metrics_tracker.update_position(asset, amount=0)
self.metrics_tracker._ledger._portfolio.positions = zp.Positions(
self.metrics_tracker.positions)
def positions(self):
z_positions = zp.Positions()
for symbol in self._tws.positions:
ib_position = self._tws.positions[symbol]
try:
z_position = zp.Position(symbol_lookup(symbol))
except SymbolNotFound:
# The symbol might not have been ingested to the db therefore
# it needs to be skipped.
continue
z_position.amount = int(ib_position.position)
z_position.cost_basis = float(ib_position.average_cost)
# Check if symbol exists in bars df
if symbol in self._tws.bars:
z_position.last_sale_price = \
float(self._tws.bars[symbol].last_trade_price.iloc[-1])
z_position.last_sale_date = \
self._tws.bars[symbol].index.values[-1]
else:
z_position.last_sale_price = None
z_position.last_sale_date = None
z_positions[symbol_lookup(symbol)] = z_position
return z_positions
