TradingPosition#

tradeexecutor.state.position.TradingPosition Python class in Trading Strategy framework.

class TradingPosition[source]#

Bases: object

Represents a single trading position.

Each position trades a single asset
Position is opened when the first trade is made
Position is closed when the last remaining quantity is sold/closed
Position can have its target trigger levels for take_profit and stop_loss
Position can have multiple trades and increase or decrease the position exposure
Positions are revalued outside the trades
Trades for the position can have different triggers: rebalance, stop los, etc.
Position can be marked as frozen meaning the automatic system does not how to clean it up

__init__(position_id, pair, opened_at, last_pricing_at, last_token_price, last_reserve_price, reserve_currency, trades=<factory>, closed_at=None, frozen_at=None, unfrozen_at=None, last_trade_at=None, portfolio_value_at_open=None, stop_loss=None, take_profit=None, notes=None)#

Parameters:

position_id (int) –
pair (TradingPairIdentifier) –
opened_at (datetime) –
last_pricing_at (datetime) –
last_token_price (float) –
last_reserve_price (float) –
reserve_currency (AssetIdentifier) –
trades (Dict[int, TradeExecution]) –
closed_at (Optional[datetime]) –
frozen_at (Optional[datetime]) –
unfrozen_at (Optional[datetime]) –
last_trade_at (Optional[datetime]) –
portfolio_value_at_open (Optional[float]) –
stop_loss (Optional[float]) –
take_profit (Optional[float]) –
notes (Optional[str]) –

Return type:

None

Methods

`__init__`(position_id, pair, opened_at, ...)
`calculate_value_using_price`(token_price, ...)
`can_be_closed`()	There are no tied tokens in this position.
`from_dict`(kvs, *[, infer_missing])
`from_json`(s, *[, parse_float, parse_int, ...])
`get_average_buy`()	Calculate average buy price.
`get_average_price`()	The average price paid for all assets on the long or short side.
`get_average_sell`()	Calculate average buy price.
`get_buy_quantity`()	How many units we have bought total
`get_capital_tied_at_open_pct`()	Calculate how much portfolio capital was risk when this position was opened.
`get_current_price`()	Get the price of the base asset based on the latest valuation.
`get_equity_for_position`()	How many asset units this position tolds.
`get_executed_trades`()
`get_failed_trades`()	Get all trades that have failed in the execution.
`get_first_trade`()	Get the first trade for this position.
`get_freeze_reason`()	Return the revert reason why this position is frozen.
`get_identifier`()	One trading pair may have multiple open positions at the same time.
`get_last_trade`()	Get the the last trade for this position.
`get_last_tx_hash`()	Get the latest transaction performed for this position.
`get_live_quantity`()	Get all tied up token quantity.
`get_loss_risk_at_open`()	What is the maximum risk of this position.
`get_loss_risk_at_open_pct`()	What is the maximum risk of this position.
`get_name`()	Get human readable name for this position
`get_net_quantity`()	The difference in the quantity of assets bought and sold to date.
`get_opening_price`()	Get the price when the position was opened.
`get_price_at_open`()	Get the price of the position at open.
`get_quantity`()	Get the tied up token quantity in all successfully executed trades.
`get_quantity_at_open`()	Get the quanaity of the asset the position at open.
`get_quantity_unit_name`()	Get the unit name we label the quantity in this position
`get_realised_profit_usd`()	Calculates the profit & loss (P&L) that has been 'realised' via two opposing asset transactions in the Position to date.
`get_sell_quantity`()	How many units we have sold total
`get_successful_trades`()	Get all trades that have been successfully executed and contribute to this position
`get_total_bought_usd`()	How much money we have used on buys
`get_total_profit_at_timestamp`(timestamp)	Get the profit of the position what it was at a certain point of time.
`get_total_profit_percent`()	How much % we have made profit so far.
`get_total_profit_usd`()	Realised + unrealised profit.
`get_total_sold_usd`()	How much money we have received on sells
`get_trades_by_strategy_cycle`(timestamp)	Get all trades made for this position at a specific time.
`get_unexeuted_reserve`()	Get the reserve currency allocated for trades.
`get_unrealised_profit_usd`()	Calculate the position unrealised profit.
`get_value`()	Get the position value using the latest revaluation pricing.
`get_value_at_open`()	How much the position had value tied after its open.
`has_automatic_close`()	This position has stop loss/take profit set.
`has_buys`()	Does is position have any spot buys.
`has_executed_trades`()	This position represents actual holdings and has executed trades on it.
`has_planned_trades`()
`has_sells`()	Does is position have any spot sells.
`has_trade`(trade)	Check if a trade belongs to this position.
`has_trigger_conditions`()	Does this position need to check for stop loss/take profit.
`has_unexecuted_trades`()
`is_closed`()	This position has been closed and does not have any capital tied to it.
`is_frozen`()	This position has had a failed trade and can no longer be automatically moved around.
`is_long`()	Is this position long on the underlying base asset.
`is_loss`()	This position is currently having non-zero losses.
`is_open`()	This is an open trading position.
`is_profitable`()	This position is currently having non-zero profit.
`is_short`()	Is this position short on the underlying base asset.
`is_stop_loss`()	Was this position ended with stop loss trade
`is_stop_loss_closed`()	Did this position close with stop loss.
`is_take_profit`()	Was this position ended with take profit trade
`is_take_profit_closed`()	Did this position close with trake profit.
`is_unfrozen`()	This position was frozen, but its trades were successfully repaired.
`open_trade`(strategy_cycle_at, trade_id, ...)	Open a new trade on position.
`schema`(*[, infer_missing, only, exclude, ...])
`set_revaluation_data`(last_pricing_at, ...)
`to_dict`([encode_json])
`to_json`(*[, skipkeys, ensure_ascii, ...])

Attributes

`position_id`	Runnint int counter primary key for positions
`pair`	Trading pair this position is trading
`opened_at`	When this position was opened
`last_pricing_at`	When was the last time this position was (re)valued
`last_token_price`	Last valued price for the base token.
`last_reserve_price`
`reserve_currency`	Which reserve currency we are going to receive when we sell the asset
`trades`	List of trades taken for this position.
`closed_at`	When this position was closed
`frozen_at`	Timestamp when this position was moved to a frozen state.
`unfrozen_at`	Timestamp when this position was marked lively again
`last_trade_at`	When this position had a trade last time
`portfolio_value_at_open`	Record the portfolio value when the position was opened.
`stop_loss`	Trigger a stop loss if this price is reached,
`take_profit`	Trigger a take profit if this price is reached
`notes`	Human readable notes about this trade

position_id: int#: Runnint int counter primary key for positions

pair: TradingPairIdentifier#: Trading pair this position is trading

opened_at: datetime#

When this position was opened

Strategy tick time.

last_pricing_at: datetime#: When was the last time this position was (re)valued

last_token_price: float#

Last valued price for the base token.

There are two ways to receive this

When the position is opened, set to the initial buy price
When the position is revalued, set to the sell price of the position

Note that this might be initially incorrect, if revaluation has not been done yet, because the buy price != sell price.

reserve_currency: AssetIdentifier#: Which reserve currency we are going to receive when we sell the asset

trades: Dict[int, TradeExecution]#: List of trades taken for this position. trade_id -> Trade map

closed_at: Optional[datetime]#: When this position was closed

frozen_at: Optional[datetime]#

Timestamp when this position was moved to a frozen state.

This can happen multiple times, so is is the last time when this happened.