v8 Framework
Search…
⌃K

Platform concepts

The SigTech platform allows you to build, backtest, and execute systematic trading strategies in a modular fashion. This process is facilitated by linking together three distinct object categories in SigTech's Python framework:
  1. 1.
    Tradable instruments
  2. 2.
    Non-tradable data
  3. 3.
    Strategies

Object orientation

The relationship between these object categories is conceptualised as follows:
Object Orientation on the SigTech Platform
Tradable instruments are broadly separated into two categories:
  • Exchange-tradable assets
  • OTC assets
Notes:
  • Both of these instrument types provide market exposure.
  • Data on exchange-tradable assets cannot be modified, only queried.
  • OTC assets can be constructed by the user with custom dates, strike prices, and other data.
Learn more: for a full list of the instruments tradable within the SigTech platform, see Instruments.
Non-tradable data is used for signal generation within the SigTech platform.
It comprises of:
  • A broad range of datasets
  • Macroeconomic indicators
  • Equity indices
  • Volatility surfaces
Similar to the data on exchange-traded assets, non-tradable data resists modification and can only be queried.
Learn more: for a full list of the non-tradable datasets accessible within the SigTech platform, see Data.
Strategies emerge from the interaction between non-tradable data and tradable instruments. They are a set of rules and logic which guide an investor’s engagement with the market over a specified time period, to do the following:
  • Generate orders to buy and sell instruments
  • Produce exposure
  • Earn P&L
Learn more: to build your own custom strategies, see Base Strategy Class.
Learn more: to view a range of pre-built strategy templates, see Strategy Templates.

Common operations: all objects

There are a number of operations commonly performed with objects. The following operations are available to all object types:
  • To retrieve an object use sig.obj.get(“EXAMPLE_TICKER”). When retrieving tradable instruments, this operation can be used for exchange-tradable assets due to them already existing in the system. OTC assets and strategies need to be created before they can be retrieved.
  • All objects have an associated time series. Use .history() to retrieve a specific time series. By passing field=“...” into the call, time series' for distinct fields such as open, volume and bid, can also be retrieved. These fields vary according to object type.
  • All objects have some form of static data associated with them, such as futures contract expiration date and stock exchange opening times. Although the data is accessible using alternative means, the .data_dict() command provides a helpful overview.
stock = sig.obj.get("1000045.SINGLE_STOCK.TRADABLE")
# Default is to retrieve the close price
print(stock.history())
print(stock.data_dict())
etf = sig.obj.get("EEM UP EQUITY")
print(etf.history(field="OPEN"))
print(etf.data_dict())
future = sig.obj.get("ESH18 COMDTY")
print(future.history(field="VOLUME"))
print(future.data_dict())
# See all fields available
print(future.history_fields)
Tip to view all the methods attached to an object, simply add a full stop after its name, then press the tab key. This will generate JupyterLab’s auto-complete menu and display all of the available methods and properties. Similarly, to view the documentation for an object, add ? to its name, then run the cell.

Common operations: tradable instruments

Tradable instruments simulate the behaviour of their respective financial market instruments, and have distinct methods and properties attached to them. The following list separates some of the available operations by asset class:

Equities

  • To display a list of all corporate actions on file for a particular stock, use .corporate_actions()
  • To retrieve the closing history of a stock adjusted for dividends and splits, use .adjusted_price_history()

Bonds

  • To display the remaining cash flows from a given date to the maturity date, use .cashflows()
  • To retrieve the yield-to-maturity given various inputs, use .ytm()

Futures & futures contract groups

  • To call on the parent to return the term structure or curve at a given date, use group().get_future_curve()

Interest rate swaps

  • To retrieve the carry and roll-down for a set of dates, use .carry_roll_down()

Options

  • To calculate various Greeks over time, use .greeks()
Note: the Data Browser allows you to view the available tradable instruments and non-tradable data, along with explanatory example code.

Common operations: strategies

All strategies inherit from the same Python base class: strategy. It is used to facilitate the integration of the framework with the timeline, providing a space to initialize the strategy and implement its underlying logic.
There are a number of common operations performed on strategies:
  • To display a chronologically ordered table of states the strategy has been in, such as positions held, orders pending, and cash held, use .plot.portfolio_table(). This operation is useful in determining if returns have materialized.
  • To retrieve the respective P&L and signal weights for the different levels of a strategy, use .analytics.pnl_breakdown(). Through the modification of the parameter levels, a granular analysis of the P&L attributed to specific assets or sub-strategies can be conducted.
  • To scale up a strategy to a specific AUM and tabulate the current positions and outstanding orders for a given time and date, use inspect.evaluate_trades().
Note: tradable instruments and strategies are considered tradable by the platform, which assigns bid and ask prices. The bid or ask spread determines the transaction cost incurred from trading an instrument or strategy, and its constituents.