Processors are objects that define interfaces on how to apply a timeseries function to a series in a DataGrid. These series can be from a DataCoordinate or from another processor which allows for nested processors. Each processor class defines how many series can be passed into the processor and any required or optional parameters for the timeseries functions. DataGrid supports many processors with the ability to seamlessly add more to GS Quant.

Supported Processors

We currently support many processors which are grouped by type. There are also API references for all our processors with detailed descriptions and usage.

Special Processors

Special processors are unlike our normal timeseries processors. They handle special use-cases such as getting data from an Entity or coordinate.

ProcessorDescriptionAPI Reference
CoordinateProcessorReturns data from a Coordinate. See example.Link
EntityProcessorReturns data such as the name or an identifier of a entity in string format.Link

Econometric Processors

Econometrics processors are for standard economic and timeseries analytics operations and other numerical operations which are generally finance-oriented.

ProcessorDescriptionAPI Reference
ChangeProcessorComputes the difference of every value from the initial value of the input series.Link
CorrelationProcessorComputes the rolling correlation of two series.Link
VolatilityProcessorComputes the realized volatility of the input series.Link
SharpeRatioProcessorComputes the Sharpe ratio of the the input seriesLink

Statistics Processors

ProcessorDescriptionAPI Reference
PercentilesProcessorComputes the rolling percentiles over given window.Link

Utility Processors

Utility processors are for generic operations on timeseries which may be useful for your analytics.

ProcessorDescriptionAPI Reference
AppendProcessorAppends two series together.Link


Coordinate Processor

Below is an example DataGrid with a CoordinateProcessor.

from import DataColumn, DataRow, DimensionsOverride, DataGrid
from import LastProcessor, EntityProcessor, CoordinateProcessor
from import DataDimension
from import DataCoordinate, DataMeasure, DataFrequency
from import AssetIdentifier, Asset
from gs_quant.session import GsSession


implied_volatility = DataCoordinate(
        DataDimension.TENOR: "3m",
        DataDimension.RELATIVE_STRIKE: 0.5,
        DataDimension.STRIKE_REFERENCE: "delta"

col_1 = DataColumn(name="Name", processor=EntityProcessor(field="name"))
col_2 = DataColumn(name="Tenor", processor=CoordinateProcessor(implied_volatility, dimension=DataDimension.TENOR))
col_3 = DataColumn(name="IV ATM", processor=LastProcessor(implied_volatility))

columns = [col_1, col_2, col_3]

SPX = Asset.get("SPX", AssetIdentifier.BLOOMBERG_ID)

rows = [
    DataRow(SPX, overrides=[
            dimensions={DataDimension.TENOR: "6m"},
    DataRow(SPX, overrides=[
            dimensions={DataDimension.TENOR: "1y"},

datagrid = DataGrid(name="SPX Implied Vol by Tenor", rows=rows, columns=columns)
datagrid.initialize(), datagrid.poll()


            Name Tenor    IV ATM
0  S&P 500 Index    3m  0.252124
1  S&P 500 Index    6m  0.243322
2  S&P 500 Index    1y  0.231568

Contributing Processors

GS Quant is Open-Source, we encourage users to create and contribute new processors for any new analytics.

All processors must inherit from the BaseProcessor which automatically handles serialization and creating the dependency graph for data fetching and other background logic. Users only need to create the process function that handles calculations and setting the procesor's value.



For contributing processors, please send merge requests and reach out to:



Please contact us at with any questions or feedback.

Related Content