InterestRateSwap#

class sigtech.framework.instruments.ir_otc.InterestRateSwap

Implements a receiver (receives fixed, pays floating) interest rate swap where its P&L excluding cashflows is calculated from a given time series. Strike will be recorded as an entry point on the time series + transaction cost assumptions (unless specified explicitly). The name will be different depending on whether the swap will start on the next IMM contract delivery date.

The history of the swap is computed to the earliest of the pricing day and swap maturity unless value_post_start is set to False in which case the swap will only have time series from entry date until start date.

If floating leg requires a spread on top of the index, it can be added as a spread parameters (in absolute terms, e.g. if a floating leg pays LIBOR+20bp, the 20bp should be input as spread=0.002).

Example object creation:

ir_swap = sig.InterestRateSwap(
    currency='USD',
    trade_date=dtm.date(2017, 4, 14),
    start_date=dtm.date(2017, 1, 3),
    tenor='5Y',
)

This will create a 5Y USD swap, that started 3-Jan-2017, matures 3-Jan-2022, receives (fixed) fair swap rate as determined on the start date, and uses USD swap defaults - semi-annual 30/360 fixed leg vs. quarterly Act/360 (3M USD LIBOR) floating leg.

ir_swap_imm = sig.InterestRateSwap(
    currency='GBP',
    trade_date=dtm.date(2015, 4, 15),
    start_date=dtm.date(2015, 6, 17),
    fixed_rate=0.07,
    tenor='10Y',
    value_post_start=False,
)

This will create an IMM (since start date is an IMM date) forward-starting 10Y GBP swap receiving 7% fixed rate (semi-annual, ACT/365), that should be traded out prior to the start date, as we don’t generate the time series for it after the start.

ir_swap = sig.InterestRateSwap(
    currency='EUR',
    trade_date=dtm.date(2017, 4, 14),
    start_date=dtm.date(2017, 1, 5),
    tenor=dtm.date(2022, 7, 5),
    fixed_rate=0.05,
)

This will create a 5.5Y EUR swap, that started 5-Jan-2017, matures 5-Jul-2022, and receives a 5% (annual, 30/360) fixed rate.

If default swap parameters need to be changed, it can be done via the overrides dictionary as follows:

ir_swap = sig.InterestRateSwap(
    currency='EUR',
    trade_date=dtm.date(2017, 4, 14),
    start_date=dtm.date(2017, 7, 5),
    tenor=dtm.date(2022, 7, 5),
    fixed_rate=0.05,
    overrides={
        'fixed_frequency': 'S',
        'discount_curve': 'EUR.F6M CURVE',
        'float_day_count': 'ACT/365F'
    }
)

This will create a 5Y EUR swap, receiving semi-annual fixed coupon, ACT365 floating leg day count, and using EUR.F6M curve for discounting its cashflows (unlike standard 5Y EUR swap that would receive annual fixed coupon, pay floating with ACT360 daycount, and would use the default EUR.D curve for discounting).

Hereunder are some supported values for various parameters:
  • fixed_frequencies : A - annual, S - semiannual, Q - quaterly

  • floating_frequencies : Tenor like string usually 3M or 6M.

  • day_count: ACT/365, ACT/360, ACT/365F, 30/360

Forecast and discount curve format are the following:
  • forecast_curve: CCY & ‘.F’ & tenor & ‘ CURVE’

  • discount_curve: CCY & ‘.d CURVE’

For supported currencies and fixes indices:

See also

sigtech.framework.instruments.constants.SWAP_FIXES_INDICES

tenor: Union[datetime.date, str]
fixed_rate: Optional[float]
start_date: Optional[datetime.date]
trade_date: datetime.date
value_post_start: Optional[bool]
spread: Optional[float]
overrides: Optional[dict]
static schedule_stub(currency, env: sigtech.framework.config.config.ConfiguredEnvironment, group_name=None)

Schedule stub for all IR swaps.

Parameters
  • currency – Input currency.

  • env – Configured environment.

  • group_name – Group name (optional).

Returns

Schedule stub.

validate()

Validation procedure for this instrument.

fixing_date(start_date)

Index fixing date for the coupon starting at start_date

static spot_date(env: sigtech.framework.config.config.ConfiguredEnvironment, asof_date, currency)

Standard swap start date if traded on asof_date.

swap_details(d: datetime.datetime, notional: float = 1.0) dict

Return swap info.

Parameters
  • d – Reference date to return info for.

  • notional – Notional (optional).

Returns

Dictionary of swap info.

swap_rate_shift_details(d: datetime.datetime, shift_bps: float = 1.0, curves: str = 'forecasting', tenor: str = 'tenors', notional: float = 1.0) dict

Return swap rate shift scenario analysis info.

Parameters
  • d – Reference date to return info for.

  • shift_bps – Swap rate shift amount in bps (optional), 1bps used as default.

  • curves – Which curve to shift (optional). 'discounting' or 'forecasting' or 'both', 'forecasting' used as default.

  • tenor – Swap rate tenor to shift (optional), e.g. '1Y', '5Y' or 'tenors' to shift all available swap rate tenors, 'tenors' used as default.

  • notional – Notional (optional).

Returns

Dictionary of scenario analysis info.

risk_ladder(d: datetime.datetime, shift_bps: float = 1.0, curves: str = 'forecasting', field: str = 'NPV', interpolation_type: str = 'CS', notional: float = 1.0) pandas.core.frame.DataFrame

Return forward and zero rate shift risk ladder for specified field. Output is change in value for this field.

Parameters
  • d – Reference date to return info for.

  • shift_bps – Fwd and zero rate shift amount in bps (optional), 1bps used as default.

  • curves – Which curve to shift (optional). 'discounting' or 'forecasting' or 'both', 'forecasting' used as default.

  • field – Field to calculate risk ladder for (optional). 'NPV' or 'PV01', 'NPV' used as default.

  • notional – Notional (optional).

  • interpolation_type – Interpolation type (optional). 'FF', 'MCF', 'FFMCF' or 'CS', 'CS' used as default

Returns

DataFrame risk ladder for pv01.

classmethod fair_swap_rate(env: sigtech.framework.config.config.ConfiguredEnvironment, currency: str, tenor: str, d, mode: str = 'mid', transaction_type: Optional[str] = None, start_date=None, overrides: Optional[dict] = None, is_imm: bool = False, data_point: sigtech.framework.infra.data_adapter.common.DataPoint = None, bid_ask_to_mid_spread_override: Optional[dict] = None) float deprecated

Calculate the fair swap rate for a given tenor on a given date. Deprecated, please use fair_rate instead.

If no start_date is passed as an input, swap is assumed to start on d + a lag depending on the currency.

Parameters
  • env – Environment to use.

  • currency – Swap currency to use.

  • tenor – Swap tenor to use.

  • d – Reference date to calculate fair swap rate for.

  • mode – (Optional) Quote to return, defaults to mid but can be bid or ask.

  • transaction_type – (Optional) Type of transaction to assume, defaults to outright but can be set to roll.

  • start_date – (Optional) Start date of swap to assume.

  • overrides – (Optional) Swap settings overrides to provide, if any. See class docstring for examples.

  • is_imm – (Optional) Whether or not the swap follows IMM date conventions, defaults to False. If True then the swap start on the next IMM date.

  • data_point – (Optional) Data point of the underlying curves

  • bid_ask_to_mid_spread_override – (Optional) mid to bid/ask to use for each transaction type.

Returns

Fair swap rate given the inputs.

fair_rate(d=None, mode: str = 'mid', transaction_type: Optional[str] = None, start_date=None, overrides: Optional[dict] = None, data_point: Optional[sigtech.framework.infra.data_adapter.common.DataPoint] = None, bid_ask_to_mid_spread_override: Optional[dict] = None, **kwargs) float

Calculate the fair swap rate for a given tenor on a given date.

If no start_date is passed as an input, swap is assumed to start on the next IMM date, that is at least one LIBOR fixing lag apart from d.

Parameters
  • d – Reference date to calculate fair swap rate (optional, defaults to instrument’s trade_date).

  • mode – Quote to return, defaults to 'mid' but can be 'bid' or 'ask' (optional).

  • transaction_type – Type of transaction to assume, defaults to outright but can be set to roll (optional).

  • start_date – Start date of swap to assume (optional).

  • overrides – Swap settings overrides to provide, if any. See class docstring for examples (optional).

  • data_point – Data point of the underlying curves (optional).

  • bid_ask_to_mid_spread_override – Mid to bid/ask to use for each transaction type (optional).

Returns

Fair swap rate given the inputs.

static swap_trading_spread(currency: str, tenor: str, d: datetime.date, transaction_type: str = 'outright') float

Get pre-defined bid/ask-mid running spread, depending on currency and tenor.

Parameters
  • currency – Currency to fetch.

  • tenor – Tenor to fetch.

  • d – Reference date to fetch spread for.

  • transaction_type – Transaction type (Optional, defaults to 'outright')

Returns

property mx_generator_name

MX name format.

property maturity

Maturity date.

static maturity_from_tenor(env: sigtech.framework.config.config.ConfiguredEnvironment, start_date, tenor, currency, bdc='NONE_RULE')

Compute maturity date from tenor.

Parameters
  • env – Configured environment.

  • start_date – Start date.

  • tenor – Tenor.

  • currency – Currency.

  • bdc – Business day convention, e.g. 'FOLLOWING', 'MOD_FOL', 'PRECEDE'.

Returns

Maturity date.

static get_calendar(currency, env: sigtech.framework.config.config.ConfiguredEnvironment)

Calendar holidays.

Parameters
  • currency – Currency.

  • env – Configured Environment.

Returns

Calendar holidays.

static swap_info_from_currency(env: sigtech.framework.config.config.ConfiguredEnvironment, start_date, tenor: str, currency: str, rate: float = 0.0001, spread: float = 0, overrides: Optional[dict] = None)

Return standard swap info summary, for quant bridge instrument creation.

Parameters
  • env – Environment to use.

  • start_date – Start date to assume for the swap.

  • tenor – Tenor to assume for the swap.

  • currency – Currency to assume for the swap.

  • rate – Rate to assume for the swap. Is often not needed.

  • spread – Floating rate spread. Most of the time it is 0 and not needed.

  • overrides – Any overrides to pass into the method.

Returns

Summary of standard swap info based on inputs.

carry_roll_down(d: datetime.date, dates: Union[str, datetime.date, list[Union[str, datetime.date]]], data_point: Optional[sigtech.framework.infra.data_adapter.common.DataPoint] = None)

Compute carry and roll-down of swap by moving the valuation date forward to the requested dates, keeping discount and forecasting curves constant, i.e. discount_factor(from_original_date, for_x_number_of_days) equals discount_factor(from_the_forward_date, for_x_number_of_days), and assuming that all the forward required IBOR fixings are equal to the valuation date (d) implied fixing.

Parameters
  • d – Valuation date.

  • dates – String/date or a list of strings/dates for which the carry/roll-down is needed.

  • data_point – Data point for the original curves.

Returns

DataFrame of 4 columns - carry - cumulative cashflows from d to date, roll_down - change in swap PV, and the same numbers scaled by swap PV01.

physical_cashflow(d: datetime.date)

Return a cash flow for a given date.

Parameters

d – Reference date.

Returns

Cash flow.

property fixed_day_count: str

Fixed day count.

add_custom_history(history: pandas.core.series.Series, field: str = 'LastPrice', data_point: Optional[sigtech.framework.infra.data_adapter.common.DataPoint] = None)

Add custom history data for this object. If multiple, conflicting custom histories are added only the last addition will be returned from history.

Parameters
  • historypd.Series of custom history with index as tz-naive, pd.DatetimeIndex dates.

  • field – Name of history field to overwrite.

  • data_point – Optional DataPoint to specify timing of custom history.

after_history_func()
property alias: Optional[str]

Return an alias string used to represent the instrument in the portfolio table or other widgets.

property allowed_clean_sparse_fields

List of fields that are allowed to have na values on clean history.

property asset_description: str

String representing the underlying asset, or None if no assets exist.

property available_data_points: Optional[list[sigtech.framework.infra.data_adapter.common.DataPoint]]

Available data points for this object.

available_data_providers(entitled_only=True) Optional[List[str]]

Available data providers for this object. Bool to return entitled providers only

property base_name

Primary name used to identify the object.

property bbg_ticker: str

Ticker for Bloomberg data vendor.

cache_history(fields: list, data_point: sigtech.framework.infra.data_adapter.common.DataPoint, start_dt: Optional[datetime.datetime] = None, end_dt: Optional[datetime.datetime] = None, **kwargs)

Ensure history data is cached

property cache_name: str

Cache name of this object.

calendar_schedule() sigtech.framework.schedules.schedule.Schedule

A calendar schedule - a schedule that is corresponding to a history schedule, but without min and max dates set.

Returns

returns calendar schedule instance for the instrument

property class_name

Class name of this object.

property class_short_name

Short name of the object class.

clear_cached_data()

Clear all the cached data of the object.

clone_object(params=None)

Return a clone of the object with amended parameters.

Parameters

params – Optional dictionary of parameters to override.

Returns

New object.

compute_dependencies(root_dependency: Optional[sigtech.framework.internal.infra.mu.graph.registry.factory.Dependency] = None)

Compute these dependencies - triggers MDS requests

static convert_dtypes(clz)

Class decorator to convert classes’ BaseType into variable annotations (PEP-526), and to generate __aliases__ based on BaseType.db_name when required.

data_available(d: Optional[datetime.date] = None) bool

Method to indicate if pricing data is available for a given date.

Parameters

d – Date of interest (optional), if not provided it will take as of date of the environment.

data_df(data_point: Optional[sigtech.framework.infra.data_adapter.common.DataPoint] = None, multi_index: bool = False, drop_nan_cols: bool = False, pretty_print=False) pandas.core.frame.DataFrame

Return a DataFrame containing all data available for this object.

Parameters
  • data_point – Optional data point used to load the object history.

  • multi_index – If set to True, rows are uniquely indexed by a multi index (if applicable). Default is False.

  • drop_nan_cols – If set to True, all-NaN columns are dropped. Default is False.

  • pretty_print – If set to True, formatting is added to columns names and data values. Rates will be represented as percentage number instead of decimal number (e.g. 3.5 instead of 0.035).

Returns

pandas DataFrame.

data_dict()

Return the object attributes in a dict.

property data_format

Return the data format associated with sparse history, i.e. ROWISE or COLUMNAR.

property data_point

Field used when retrieving history.

property data_source

Data provider of the instrument.

property data_source_all: Optional[list[str]]

Available data points for this object.

data_validation(sparse_series)

Additional data checks can be implemented in sub classes here.

property default_data_point

Default data point for this object.

dependencies(input_dependency: Optional[sigtech.framework.internal.infra.mu.graph.registry.factory.Dependency] = None, valuation_currency: Optional[str] = None, use_start: bool = True) list[sigtech.framework.internal.infra.mu.graph.registry.factory.Dependency]

Returns a list of Dependency

Parameters
  • input_dependency – A Dependency object representing the root of the dependency tree to be returned.

  • valuation_currency – If supplied, include the dependencies required to output the data in this currency.

  • use_start – If False, return only dependencies required to calculate an earliest start date - self.start_date will be None in this case.

Returns

List of Dependency objects representing the current level in the dependency tree.

property dependency_type

Dependency type

property env: sigtech.framework.config.config.ConfiguredEnvironment

Return the configured environment.

env_date_change(old_env_dt: datetime.datetime, new_env_dt: datetime.datetime, live_data_update=None)

Routine called after the environment date is changed.

Parameters
  • old_env_dt – Old datetime (tz aware).

  • new_env_dt – New datetime (tz aware).

  • live_data_update – Live streaming data associated with the environment date change.

exchange() Any

Object for exchange (or substitute, e.g. 'OTCLN') on which instrument trades.

property exchange_code: str

Exchange code for traded instruments belonging to this group.

property expiry_date: datetime.date

Date when the contract expires, or last date on which we can trade.

property expiry_dt: datetime.datetime

Datetime when the contract expires, or last datetime at which we can trade.

finalize_for_comparison()

Method to call to ensure all data dict values are finalized prior to doing object comparisons.

property float_day_count: str

Floating day count.

classmethod from_dictionary(dct: dict[str, Any], cache: bool = True, identifier: Optional[sigtech.framework.infra.data_adapter.identifier.Identifier] = None, env: Optional[sigtech.framework.config.config.ConfiguredEnvironment] = None, **kwargs)

Factory method to create object using data dictionary

classmethod get_names(sort_by_group: Optional[bool] = False, include_db: Optional[bool] = True, include_local: Optional[bool] = True, include_children: Optional[bool] = False, ignore_unmapped: Optional[bool] = True) list[str]

Return an ordered list of object names associated with the class.

Parameters
  • sort_by_group – If set, the list is first ordered by sector/group, if applies, e.g. commodity or index futures (default is False).

  • include_db – If set, include objects available from the database (default is True).

  • include_local – If set, include objects available in the local environment (default is True).

  • include_children – If set, include objects available from child classes (default is False).

  • ignore_unmapped – If set, ignore errors due to unmapped database objects (default is True).

Returns

List of object names.

group() any

Group of this object.

has_preloaded_history(fields=None, data_point=None)

Check if the object has preloaded history.

history(field: str = None, adjust_for_delay: bool = False, date_index: bool = False, data_point: Optional[sigtech.framework.infra.data_adapter.common.DataPoint] = None, datetime_index: bool = False) pandas.core.series.Series

Method to retrieve time series for objects overlaid by history schedule and publication delay (optional). If the given field does not exist, an empty series will be returned.

Parameters
  • field – Optional - Returns time series for field - defaults to prime history field.

  • adjust_for_delay – Optional - Returns adjusted index if there is a publication delay.

  • date_index – Optional - Convert the timestamp index to dates.

  • data_point – data point to retrieve - from self.available_data_points

  • datetime_index – Optional - if True, populate the time and UTC timezone information in the index.

Returns

pd.Series.

history_dates()

Return all the dates we should have actual history values.

history_dates_actual()

Return all the dates we have actual history values.

history_dates_eventual()

Return all the dates we will eventually have history values.

history_df(fields: list[str] = None, data_point: sigtech.framework.infra.data_adapter.common.DataPoint = None, multicolumn: bool = None) deprecated

Return the object history dataframe.

Parameters
  • fields – list of fields. If not supplied, self.history_fields will be used

  • data_point – optional data point used to load the object history.

  • multicolumn – Deprecated input. This will be removed in future releases.

Returns

pd.DataFrame.

history_end_date() datetime.date

Eventual history end date, truncated to the as of date - the day on which history should end.

history_end_date_actual()

The last date we have an actual value for.

history_end_date_eventual() datetime.date

Last date for which data will be available - typically date.max if no end date set.

history_end_timestamp() pandas._libs.tslibs.timestamps.Timestamp
Returns

First timestamp for which data should be available

property history_fields: list[str]

The fields of history retrieved for this instrument.

history_schedule() sigtech.framework.schedules.schedule.Schedule

Object describing dates on which history is available and the corresponding delivery times.

Returns

History schedule instance for the instrument.

history_start_date() datetime.date

First date for which data should be available.

history_start_timestamp() pandas._libs.tslibs.timestamps.Timestamp
Returns

First timestamp for which data should be available

property holidays

List of holiday calendars for this instrument.

property identifier: sigtech.framework.infra.data_adapter.identifier.Identifier

Return the object identifier.

info() dict

Return a dictionary with useful object information.

property input_parameters

Values of initial input parameters entered when creating the instance.

property instrument_type: str
Returns

Classification using class name of instruments.

property internal_id

Ticker - i.e. part of name determining content of the class. For types with saved reference data - ticker will be self._ticker. For software types - ticker should be calculated.

intraday_history(field=None, period=None, start_dt=None, end_dt=None, daily_timeseries_time=None, daily_timeseries_tz=None, filter_by_trading_sessions=False, timezone=None, convert_yield_to_price=True)

Retrieve intraday history for this instrument as a Series.

Parameters
  • field – field name in self.intraday_history_fields.

  • period – a dtm.timedelta giving the desired periodicity of the data.

  • start_dt – optional tz-aware dtm.datetime giving a desired start point.

  • end_dt – optional tz-aware dtm.datetime giving a desired end point.

  • daily_timeseries_time – if supplied, the intraday data will be down-sampled to daily data snapped at this time.

  • daily_timeseries_tz – timezone for the above. Optional, if not supplied defaults to self.valuation_tzinfo

  • filter_by_trading_sessions – If False ``(default), return all available data. If ``True return data during the main trading session. If a string/list(string), return data during the trading session(s) of that name according to self.group().session_data(). See intraday_trading_sessions() for list of sessions.

  • timezone – set the timezone of the returned series to this value

  • convert_yield_to_price – applies yield to price conversion for yield quoted futures, e.g. AUD bond futures

Returns

A (possibly sparse) pd.Series with a DateTimeIndex. Times should be tz-aware UTC.

intraday_history_df(fields=None, period=None, start_dt=None, end_dt=None, daily_timeseries_time=None, daily_timeseries_tz=None, filter_by_trading_sessions=False, timezone=None, convert_yield_to_price=True)

Retrieve intraday history for this instrument as a dataframe.

Parameters
  • fields – a list of field names all in self.intraday_history_fields.

  • period – a dtm.timedelta giving the desired periodicity of the data.

  • start_dt – optional tz-aware dtm.datetime giving a desired start point.

  • end_dt – optional tz-aware dtm.datetime giving a desired end point.

  • daily_timeseries_time – if supplied, the intraday data will be down-sampled to daily data snapped at this time.

  • daily_timeseries_tz – timezone for the above. Optional, if not supplied defaults to self.valuation_tzinfo

  • filter_by_trading_sessions – If False ``(default), return all available data. If ``True return data during the main trading session. If a string/list(string), return data during the trading session(s) of that name according to self.group().session_data()

  • timezone – set the timezone of the returned dataframe to this value

  • convert_yield_to_price – applies yield to price conversion for yield quoted futures, e.g. AUD bond futures

Returns

A (possibly sparse) pd.DataFrame with a DateTimeIndex. Times should be tz-unaware UTC.

property intraday_history_fields: list[str]

The intraday fields of history retrieved for this instrument.

intraday_trading_sessions()

Gets ths list of trading sessions available as per the Copp-Clarke session data for this product group

is_cash() bool

Return True if the instrument represents a cash/margin amount.

is_exchange_traded() bool

Return True if this instrument is traded on an exchange.

is_expandable() bool

Return True if the instrument can be expressed in terms of a portfolio of other instruments.

is_margin() bool

Check if the instrument represents a margin amount.

is_margin_accountable() bool

Check if an artificial margin is created to account for price changes in instruments that do not require immediate payment, but have a nominal value, e.g. futures. The actual P&L is computed through this artificial margin for such instruments.

is_notional_exposure_calc_needed() bool

Check if the notional exposure weight should be computed and included in the interactive portfolio table, e.g. for options, FX forwards, IR swaps.

is_option() bool

Return True if the instrument is an option.

is_otc() bool

Is this instrument OTC traded?

is_strategy() bool

Return True if this object is a strategy.

property is_unmapped

Check if the object is not mapped.

property live_supported: bool

Flag for live supported objects.

property name

Primary name by which the FrameworkObject is identified. If reference information (or e.g. corresponding time series) are stored in the DB, then this name will be used.

order_class() Any

Return the order class for timeline processing.

property order_rounding

The value to which the units should be rounded to when calculating target units. Eg, 1000 would round to the nearest thousand :return: order rounding factor

otc_fields_to_persist = []
property position_type: str

Display trade type.

positions_to_units(position, dt)

Strategy scaling function: convert positions to number of units.

Parameters
  • position – Number of positions.

  • dt – Input scaling date.

Returns

Number of units.

positions_to_units_multiplier(dt)

Strategy scaling function: multiplier to convert positions to number of units.

Parameters

dt – Input scaling date.

Returns

multiplier

property prime_history_field: str

The main history field returned by default.

property prime_intraday_history_field

The main intraday history field returned by default.

classmethod print_add_trade_kwargs()

Print the keyword arguments for the Strategy add_trade method.

print_dependencies(root_dependency: Optional[sigtech.framework.internal.infra.mu.graph.registry.factory.Dependency] = None, resolve_future_dependencies: bool = True, fields: Optional[list] = None)

Pretty print dependency tree :param root_dependency: starting dependency of the tree. :param resolve_future_dependencies: resolve future dependencies before printing. If ‘false’ nothing get printed. :param fields: additional fields to extract from dependencies object. Default fields are product_type, currency, frequency and data_source. To get the list of available fields for an object you can use the data_dict() method.

property product_type

Return the product_type property of this object.

publication_delay() str

Publication delay of data for this instrument.

pv01_to_notional(pv01: float, dt: Union[datetime.datetime, datetime.date]) float

Convert target pv01 to required swap notional (such that swap with this notional has the target pv01) :param pv01: target pv01 position :param dt: valuation time (or date, with default data point used in that case) :return: equivalent notional at dt

realign_history(series)

Realign history series to proper business days.

Parameters

series – Input series.

Returns

Realigned history series.

rounded_units(units, dt, to_trade=True)

The number of units allowed to trade for a specified target number of units, at the provided time.

This should be overwritten for instrument specific rounding logic.

The ‘to_trade’ flag switches between the use case of rounding the position for trade execution or for analysis The trading case can be different because the position is held for an extended time, while in the case of analysis you can consider the instantaneous amount of rounding allowed. An example of this applied is for the strategies where the underlying positions change over time.

Parameters
  • units – Target number of units.

  • dt – Datetime.

  • to_trade – Boolean flag to switch between allowed to open for an extended time (True) or at that instant.

property sector

Sector used on BBG, or the class ID for SIG instruments.

set_preloaded_history(data) None

Set the preloaded history of the object.

Parameters

data – History data.

set_sparse_history(data) None

Set the sparse history of the object.

Parameters

data – History data.

property settlement_type: str

Stub indicating how final cash flows are exchanged.

property size_type: str

Type of trade size for the instrument.

sizing_price(sizing_dt: datetime.datetime, ccy: Optional[str] = None, execution_dt: Optional[datetime.datetime] = None) float

On the base class this is just the valuation price, but can be overwritten in derived classes For specific instrument, price on sizing date (eg T-1), isn’t necessarily the best approximation for today’s price if the market doesn’t move.

For instance, for bonds, if coupon is to be paid on Settlement(T), then today’s price would be approximately yesterday price - coupon.

Parameters
  • sizing_dt – Sizing datetime

  • ccy – Currency string identifier

  • execution_dt – Execution datetime

Returns

Sizing price used in weight to model unit calculations

static sort_key_static(name)

Convert a name to the sort key as of Portfolio Presentation Guidelines for performance reasons.

Parameters

name – Input name.

Returns

Tuple (sort key, length of sort key, input name).

property supplementary_fields: list[str]

Additional fields available for the group.

swap_past_flows(d: datetime.date, notional: float = 1.0) dict

Experimental function - interface and output might change by the next release.

textual_representation()

Return a printable representation of this object.

trade_line(units, dt, rounded_units=True)

Trade entry containing information about units and string representation.

Parameters
  • units – Number of units.

  • dt – Size date.

  • rounded_units – If True, use rounded units to get positions (optional True by default).

Returns

Scaled units and trade description.

property trade_name: str

String identifier used for order/trade generation.

trade_price(trade_dt: datetime.datetime, trade_sign: float, include_trading_costs: Optional[bool] = True, transaction_type: Optional[str] = None, currency: Optional[str] = None, cache_trade_date: Optional[bool] = True) float

Price Traded - gives either bid or ask depending on trade type.

Parameters
  • trade_dt – Trading datetime

  • trade_sign – Integer/float to determine if it is a buy or sell

  • include_trading_costs – If True will apply trading cost adjustment otherwise ignores it

  • transaction_type – String identifier to indicate type of transaction, e.g. ‘outright’, ‘roll’

  • currency – Currency string stub

  • cache_trade_date – Optional parameter to cache trading dates of instrument

Returns

Trade/fill price

trade_price_adjustment(d: datetime.datetime, include_trading_costs: Optional[bool] = True, transaction_type: Optional[str] = None, cache_trade_date: Optional[bool] = True) float

Trade price adjustment (TPA) formula:

\[TPA_t = \alpha * S_t^{Mid} + \beta\]
Parameters
  • d – Trading date

  • include_trading_costs – If True will apply trading cost adjustment otherwise ignores it

  • transaction_type – String identifier to indicate type of transaction, e.g. ‘outright’, ‘roll’

  • cache_trade_date – Optional parameter to cache trading dates of instrument

Returns

Trade price adjustment

trade_price_adjustment_add(d: datetime.datetime, transaction_type: Optional[str] = None, cache_trade_date: Optional[bool] = True) float

Absolute adjustment to the mid price value in the trade price adjustment.

Parameters
  • d – Trade date

  • transaction_type – String identifier to indicate type of transaction, e.g. ‘outright’, ‘roll’

  • cache_trade_date – Optional parameter to cache trading dates of instrument

trade_price_adjustment_multiply(d: datetime.datetime, transaction_type: Optional[str] = None, cache_trade_date: Optional[bool] = True) float

Multiplier to the mid price value in the trade price adjustment

Parameters
  • d – Trade date

  • transaction_type – String identifier to indicate type of transaction, e.g. ‘outright’, ‘roll’

  • cache_trade_date – Optional parameter to cache trading dates of instrument

trade_price_ask(trade_dt: datetime.datetime, include_trading_costs: Optional[bool] = True, transaction_type: Optional[str] = None, currency: Optional[str] = None, cache_trade_date: Optional[bool] = True) float

Ask price at a point in time.

Parameters
  • trade_dt – Trading datetime

  • include_trading_costs – If True will apply trading cost adjustment otherwise ignores it

  • transaction_type – String identifier to indicate type of transaction, e.g. ‘outright’, ‘roll’

  • currency – Currency string stub

  • cache_trade_date – Optional parameter to cache trading dates of instrument

Returns

Ask trade price

trade_price_bid(trade_dt: datetime.datetime, include_trading_costs: Optional[bool] = True, transaction_type: Optional[str] = None, currency: Optional[str] = None, cache_trade_date: Optional[bool] = True) float

Bid price at a point in time.

Parameters
  • trade_dt – Trading datetime

  • include_trading_costs – If True will apply trading cost adjustment otherwise ignores it

  • transaction_type – String identifier to indicate type of transaction, e.g. ‘outright’, ‘roll’

  • currency – Currency string stub

  • cache_trade_date – Optional parameter to cache trading dates of instrument

Returns

Bid trade price

trade_schedule() sigtech.framework.schedules.schedule.Schedule

Schedule giving trade dates + last time at which we can trade for that date (i.e. notice time for funds).

Returns

Trade schedule instance for the instrument.

units_to_positions(units, dt)

Strategy scaling function: convert number of units to positions.

Parameters
  • units – Number of units.

  • dt – Input scaling date.

Returns

Number of positions.

valuation_dt(d: datetime.date) datetime.datetime

Valuation dt - datetime for a given valuation date.

valuation_point() str

Valuation Point - from this we can infer the field, time and timezone for the valuation.

valuation_price(dt: datetime.datetime, ccy: Optional[str] = None) float

Price on given valuation date.

Parameters
  • dt – Input valuation date

  • ccy – Currency string identifier

Returns

Valuation price for given input date dt

valuation_price_base(dt: Union[datetime.datetime, datetime.date]) float

Return the price in base currency on a given valuation date.

Parameters

dt – Input date/datetime.

Returns

float.

valuation_price_history(ccy: Optional[str] = None, field: Optional[str] = None, history_fill: Optional[bool] = None) pandas.core.frame.DataFrame

Return a history of valuation (available for each weekday) prices.

Parameters
  • ccy – Currency string identifier.

  • field – History field.

  • history_fill – Should gaps in history be forward filled?

Returns

Valuation history.

valuation_price_series(dts: list[datetime.datetime], ccy: Optional[str] = None, intraday_data: Optional[bool] = True) pandas.core.series.Series

Series of prices at the gives date-times.

Parameters
  • dts – List of date times

  • ccy – Currency string identifier

  • intraday_data – Use intraday data (optional, default True).

Returns

Valuation price series

property valuation_time

Valuation time for the instrument.

property valuation_tzinfo

Valuation timezone info.

wait_for_live_data(period: Optional[Union[datetime.datetime, str]] = None)

Waits until live data is collected up to and including env.asofdatetime :param period: period of the live intraday data to wait for (defaults to 1 minute)

activity_fields: Optional[list[str]]
group_name: Optional[str]
description: Optional[str]
currency: str
ticker: Optional[str]
db_ticker: Optional[str]
db_sector: Optional[str]
price_factor: Optional[float]
use_price_factor: Optional[bool]
intraday_times: Optional[list]
intraday_tz_str: Optional[str]
instrument_id: Optional[int]