StrategyRunner#

tradeexecutor.strategy.runner.StrategyRunner Python class in Trading Strategy framework.

class StrategyRunner[source]#

Bases: ABC

A base class for a strategy executor.

Each different strategy type needs its own runner. Currently we have

TODO: Make user_supplied_routing_model non-optional after eliminating legacy code.

__init__(timed_task_context_manager, execution_model, approval_model, valuation_model_factory, sync_model, pricing_model_factory, execution_context, routing_model=None, run_state=None, accounting_checks=False)[source]#

Parameters:

timed_task_context_manager (AbstractContextManager) –
execution_model (ExecutionModel) –
approval_model (ApprovalModel) –
valuation_model_factory (ValuationModelFactory) –
sync_model (Optional[SyncModel]) –
pricing_model_factory (Callable[[ExecutionModel, StrategyExecutionUniverse, RoutingModel], PricingModel]) –
execution_context (ExecutionContext) –
routing_model (Optional[RoutingModel]) –
run_state (Optional[RunState]) –

Methods

`__init__`(timed_task_context_manager, ...[, ...])
`check_accounts`(universe, state)	Perform extra accounting checks on live trading startup.
`check_position_triggers`(clock, state, ...)	Check stop loss/take profit for positions.
`is_progress_report_needed`()	Do we log the strategy steps to logger?
`on_clock`(clock, universe, pricing_model, ...)	Perform the core strategy decision cycle.
`pretick_check`(ts, universe)	Called when the trade executor instance is started.
`refresh_visualisations`(state, universe)	Update the visualisations in the run state.
`repair_state`(state)	Repair unclean state issues.
`report_after_execution`(clock, universe, ...)
`report_after_sync_and_revaluation`(clock, ...)
`report_before_execution`(clock, universe, ...)
`report_strategy_thinking`(...)	Strategy admin helpers to understand a live running strategy.
`revalue_portfolio`(ts, state, valuation_method)	Revalue portfolio based on the data.
`setup_routing`(universe)	Setups routing state for this cycle.
`sync_portfolio`(strategy_cycle_ts, universe, ...)	Adjust portfolio balances based on the external events.
`tick`(strategy_cycle_timestamp, universe, ...)	Execute the core functions of a strategy.

Parameters:

timed_task_context_manager (AbstractContextManager) –
execution_model (ExecutionModel) –
approval_model (ApprovalModel) –
valuation_model_factory (ValuationModelFactory) –
sync_model (Optional[SyncModel]) –
pricing_model_factory (Callable[[ExecutionModel, StrategyExecutionUniverse, RoutingModel], PricingModel]) –
execution_context (ExecutionContext) –
routing_model (Optional[RoutingModel]) –
run_state (Optional[RunState]) –

abstract pretick_check(ts, universe)[source]#

Called when the trade executor instance is started.

Parameters:

client – Trading Strategy client to check server versions etc.
universe (StrategyExecutionUniverse) – THe currently constructed universe
ts (datetime) – Real-time clock signal or past clock timestamp in the case of unit testing

Raises:

PreflightCheckFailed – In the case we cannot go live

is_progress_report_needed()[source]#

Do we log the strategy steps to logger?

Disabled for backtesting to speed up
Can be enabled by hacking this function if backtesting needs debugging

Return type:: bool

sync_portfolio(strategy_cycle_ts, universe, state, debug_details)[source]#

Adjust portfolio balances based on the external events.

External events include

Deposits
Withdrawals
Interest accrued
Token rebases

Parameters:

strategy_cycle_ts (datetime) –
universe (StrategyExecutionUniverse) –
state (State) –
debug_details (dict) –

revalue_portfolio(ts, state, valuation_method)[source]#

Revalue portfolio based on the data.

Parameters:

ts (datetime) –
state (State) –
valuation_method (ValuationModel) –

on_clock(clock, universe, pricing_model, state, debug_details)[source]#

Perform the core strategy decision cycle.

Parameters:

clock (datetime) – The current cycle timestamp
universe (StrategyExecutionUniverse) – Our trading pairs and such. Refreshed before the cycle.
pricing_model (PricingModel) – When constructing trades, uses pricing model to estimate the cost of a trade.
state (State) – The current trade execution and portfolio status
debug_details (dict) –

Returns:

List of new trades to execute

Return type:

List[TradeExecution]

report_strategy_thinking(strategy_cycle_timestamp, cycle, universe, state, trades, debug_details)[source]#

Strategy admin helpers to understand a live running strategy.

Post latest variables
Draw the single pair strategy visualisation.

Parameters:

strategy_cycle_timestamp (datetime) – real time lock
cycle (int) – Cycle number
universe (TradingStrategyUniverse) – Currnet trading universe
trades (List[TradeExecution]) – Trades executed on this cycle
state (State) – Current execution state
debug_details (dict) – Dict of random debug stuff

setup_routing(universe)[source]#

Setups routing state for this cycle.

Parameters:: universe (StrategyExecutionUniverse) – The currently tradeable universe
Returns:: Tuple(routing state, pricing model, valuation model)
Return type:: Tuple[RoutingState, PricingModel, ValuationModel]

tick(strategy_cycle_timestamp, universe, state, debug_details, cycle_duration=None, cycle=None)[source]#

Execute the core functions of a strategy.

Parameters:

strategy_cycle_timestamp (datetime) – Current timestamp of the execution cycle.
universe (StrategyExecutionUniverse) – Loaded trading data
state (State) – The current state of the strategy (open position, past trades, visualisation)
debug_details (dict) – Internal bunch of data used in unit testing
cycle_duration (Optional[CycleDuration]) – The currenct cycle duration (time between ticks). This may be specific in a strategy module, but also overridden for testing. This is used only for logging purposes.
cycle (Optional[int]) – Strategy cycle number
execution_context – Live or backtesting

Returns:

Debug details dictionary where different subsystems can write their diagnostics information what is happening during the dict. Mostly useful for integration testing.

Return type:

dict

check_position_triggers(clock, state, universe, stop_loss_pricing_model, routing_state)[source]#

Check stop loss/take profit for positions.

Unlike trade balancing in tick()

Stop loss/take profit can occur only to any existing positions. No new positions are opened.
Trading Universe cannot change for these triggers, but remains stable between main ticks.
check_position_triggers() is much more lightweight and can be called much more frequently, even once per minute

Returns:

List of generated stop loss trades

Parameters:

clock (datetime) –
state (State) –
universe (StrategyExecutionUniverse) –
stop_loss_pricing_model (PricingModel) –
routing_state (RoutingState) –

Return type:

List[TradeExecution]

repair_state(state)[source]#

Repair unclean state issues.

Currently supports

Fixing unfinished trades

Returns:: List of fixed trades
Parameters:: state (State) –
Return type:: List[TradeExecution]

refresh_visualisations(state, universe)[source]#

Update the visualisations in the run state.

This will update RunState.visualisations for the current strategy.

In-process memory charts are served by webhook
In-process memory charts are posted to Discord, etc.
This is called on the startup, so that we have immediately good visualisation to show over the webhook when the web server boots up
This is called after each strategy thinking cycle is complete.

The function is overridden by the child class for actual strategy runner specific implementation.

Parameters:

state (State) –
universe (TradingStrategyUniverse) –

check_accounts(universe, state)[source]#

Perform extra accounting checks on live trading startup.

Must be enabled in the settings. Enabled by default for live trading.

Raises:

UnexpectedAccountingCorrectionIssue – Aborting execution.

Parameters:

universe (TradingStrategyUniverse) –
state (State) –