RollingFutureStrategy#

class sigtech.framework.strategies.rolling_future_strategy.RollingFutureStrategy

Baseclasses: RollingStrategyBase

Subclasses: RollingLMEFutureStrategy, RollingFutureFXHedgedStrategy, DynamicRollingFutureStrategy

Class implementing rolling future strategies potentially rolled over multiple days.

Keyword arguments:

contract_code: Contract code for futures contract group to trade.
contract_sector: Contract sector, e.g. 'INDEX', 'COMDTY', for futures contract group to trade.
contract_offset: Offset to add to roll table, e.g. 1 for first month, 2 for second month, etc. Optional, defaults to zero meaning no offset from the raw roll table.
rolling_rule: Available options can be found from RollingFutureStrategy.available_rolling_rules(). If custom_rolling_table is passed, rolling_rule will be either 'custom_roll' or 'custom_table' according to the type passed.
custom_roll_table: Allows passing of a custom roll table. The custom_roll_table can be of two types :
- 'roll_table' is a list of strings of month codes to hold with key 0 (this year) or 1 (next year), e.g. ['H[0]', 'K[0]', 'K[0]', 'N[0]', 'N[0]', 'U[0]', 'U[0]', 'X[0]', 'X[0]', 'F[1]', 'F[1]', 'H[1]'] where the columns are Jan-Dec and correspond to the month during which to hold the said month code. E.g. F[1] in the 10th column means the strategy will hold next year’s Jan contract in October of this year. This will set rolling_rule to 'custom_roll'.
- 'rolling_table' is a DataFrame where the index is a datetime index and the columns are 'rolled_in_contract', 'rolled_out_contract', 'rolled_in_weight', 'rolled_out_weight' and 'first_execution_date'. This will set rolling_rule to 'custom_table'.
front_offset: If using front as rolling_rule, this parameter specifies number of business days before first delivery notice date (or expiry date for cash settled futures) to start and finish the roll. Note that there are two syntax:
- x,y include y in the offset range, e.g. -5,-3 will roll a third of the contract each of the 3 days from 4th to 2nd day before contract expiry (-1 means on expiry date).
- x:y exclude the end of the range, e.g. -5:-3 will roll half the contracts 4 days before expiry and roll the other half 3 days before contract expiry (indexed one away from -3). This syntax will be deprecated in v10.

Use front_offset_from_expiry=True if you want to specify front offset from expiry date regardless of first delivery notice date. If rolling_rule is not 'front' or 'custom_roll', this argument is ignored.

front_offset_from_expiry: Specify to use expiry date as contract expiry date regardless of first notice day.
month_end_offset: Only required if rolling_rule set to prev_month. Defines how many business days before end of month to start and finish the roll (identical syntax to front_offset).
monthly_roll_days: Defines which business day of the month to roll the contracts on. Only required if rolling_rule not set to front or prev_month, defaults to None. If None, will default to 5:9 unless rici rule is used (see sigtech.framework.schedules.roll_schedules.methods.rolling_rici for more information). Note that 5,9 syntax is available for that field and will become the norm.
roll_on_calendar_days: Optional, defaults to False. If True, front_offset, month_end_offset and monthly_roll_days will use calendar days instead of business days to compute the rolling dates. Rolling dates will still be adjusted.
leverage: Optional, defaults to 1.
transaction_type: 'outright' or 'roll' (default).
order_type: 'group', 'split' or 'auto'.
dv01_exposure: Optional, only applicable to interest rate futures and bond futures, determines the fixed DV01 exposure as a percentage of the initial_cash.
custom_roll_override: Pass a dict {year: roll schedule} to override custom_roll_table for particular years, otherwise custom_roll_table applies. This will set rolling_rule to 'custom_roll'.
rolling_approach: Either 'weight' (default) or 'contracts'. If 'weight' the roll maintains the full previous contract value into the new contract, considering the difference in prices. Otherwise, if contracts, the strategy initially fully invests in the first contract and rolls exactly this many units into subsequent contracts.
fixed_contracts: Optional, overwrite default behaviour and trade a fixed number of contracts throughout the strategy. If set, the strategy initially trades into fixed_contracts contracts and rolls exactly this many into subsequent contracts. Otherwise, if None (default), the strategy will fully invest in the initial contract and will roll into subsequent contracts as determined by rolling_approach.
run_with_future_check: Optional, boolean flag to activate a check on the futures held in the strategy. This is de-activated by default.
size_from_first_roll_trade: Optional, boolean flag to size all roll trades from the first trade of the roll. This is activated by default. The alternative sizes each trade individually.
trade_out_end: If true, closes all positions on last trading day of strategy.
allow_roll_adjustments: If set to False, rolling adjustments to accommodate specific contract expirations are not allowed. If adjustments are allowed, warnings explaining the nature of the adjustments will be provided. Default is True.

Example object creation:

import datetime as dtm

rfs = sig.RollingFutureStrategy(
    currency='USD',
    start_date=dtm.date(2016, 1, 4),
    end_date=dtm.date(2021, 11, 30),
    contract_code='ES',
    contract_sector='INDEX',
    rolling_rule='front',
    front_offset='-3,-2'
)

Roll tables are generated using helper functions implementing the different roll rules. Method build_decisions() runs through each entry in the roll table and converts it to the format expected by the strategy API.

Each row in the roll table corresponds to a roll date and consists of:

['rolled_out_contract', 'rolled_in_contract', 'rolled_out_weight', 'rolled_in_weight', 'first_execution_date']

Example rows for a roll over multiple days:

>>> date(2010, 3, 1) -> ['LPH10 COMDTY', 'LPJ10 COMDTY', '0.8', '0.2', date(2010, 3, 1)]
>>> date(2010, 3, 2) -> ['LPH10 COMDTY', 'LPJ10 COMDTY', '0.6', '0.4', date(2010, 3, 1)]
>>> date(2010, 3, 3) -> ['LPH10 COMDTY', 'LPJ10 COMDTY', '0.4', '0.6', date(2010, 3, 1)]
>>> date(2010, 3, 4) -> ['LPH10 COMDTY', 'LPJ10 COMDTY', '0.2', '0.8', date(2010, 3, 1)]
>>> date(2010, 3, 5) -> ['LPH10 COMDTY', 'LPJ10 COMDTY', '0.0', '1.0', date(2010, 3, 1)]

The required format for the strategy API is:

>>> rfs.add_position_target(decision_dt, instrument_name, weight, execution_dt, size_date, unit_type='WEIGHT')

instrument_name, weight and execution_dt are directly taken from the roll table entries (roll date -> execution_dt). decision_dt is calculated from first_execution_date using an API function. The same applies for the size date.

In case of rolls over multiple days the size date will be the same on the roll in and roll out, i.e. one size date per future contract.

allow_roll_adjustments: Optional[bool]

contract_code: str

contract_offset: Optional[int]

contract_sector: str

currency: Optional[str]

custom_roll_override: Optional[dict]

custom_roll_table: Optional[Union[DataFrame, Series, list[str]]]

dv01_exposure: Optional[float]

fixed_contracts: Optional[float]

front_offset: Optional[str]

front_offset_from_expiry: Optional[bool]

property holidays

List of known holiday calendars.

leverage: Optional[float]

month_end_offset: Optional[str]

monthly_roll_days: Optional[str]

order_type: Optional[Literal['group', 'split', 'auto']]

roll_on_calendar_days: Optional[bool]

rolling_approach: Optional[Literal['weight', 'contracts']]

rolling_rule: Optional[str]

property rolling_table

Strategy roll table.

run_with_future_check: Optional[bool]

size_from_first_roll_trade: Optional[bool]

trade_out_end: Optional[bool]

transaction_type: Optional[str]

static available_rolling_rules()→ list[str]

Utility to quickly show the available rolling rules. See RollSchedule for more details.

Returns:: List of strings of rolling rule keywords to specify roll table.

bd_schedule()

Business days schedule for the strategy.

build_rolling_table()

Builds the strategy’s rolling table.

Returns:: Built rolling table as a pandas DataFrame.

static build_weight_df(rolling_table, history_schedule, start_date, end_date)

Build a dataframe of weights where future contracts are the columns.

static calc_adj_offset(rolling_table, weight_df, back_adjustment_type, start_date, end_date, underlying_history)

Build a series of adjustment offset.

check_futures_valid(dt)

Check whether futures we have are not expiring while held in portfolio.

Parameters:: dt – Reference datetime.

clean_up_margins(dt)

Schedule margin clean-up after we buy futures every day.

Parameters:: dt – Reference datetime.