def __init__(self,
name,
timestamps,
values,
plot_type='line',
line_type='solid',
line_width=None,
color=None,
marker=None,
marker_size=50,
marker_color='red'):
'''Args:
name: Name to show in plot legend
timestamps: pandas Series or numpy array of datetime64
values: pandas Series or numpy array of floats
plot_type: 'line' or 'scatter'
marker: If set, show a marker at each value in values. See matplotlib marker types
'''
self.name = name
self.timestamps = series_to_array(timestamps)
self.values = series_to_array(values)
self.plot_type = plot_type
self.line_type = line_type
self.color = color
self.line_width = line_width
if plot_type == 'scatter' and marker is None:
raise Exception('marker must be set for plot_type scatter')
self.marker = marker
self.marker_size = marker_size
self.marker_color = marker_color
self.time_plot = True
def __init__(self,
name,
x,
y,
plot_type='line',
line_type='solid',
line_width=None,
color=None,
marker=None,
marker_size=50,
marker_color='red'):
'''
Args:
x: pandas series or numpy array of floats
y: pandas series or numpy arry of floats
'''
self.name = name
self.x = series_to_array(x)
self.y = series_to_array(y)
self.plot_type = plot_type
if plot_type == 'scatter' and marker is None: marker = 'X'
self.line_type = line_type
self.line_width = line_width
self.color = color
self.marker = marker
self.marker_size = marker_size
self.marker_color = marker_color
self.time_plot = False
def __init__(self,
name: str,
x: Union[np.ndarray, pd.Series],
y: Union[np.ndarray, pd.Series],
display_attributes: DisplayAttributes = None) -> None:
self.name = name
self.x = series_to_array(x)
self.y = series_to_array(y)
if display_attributes is None: display_attributes = LinePlotAttributes()
self.display_attributes = display_attributes
def __init__(self,
name: str,
timestamps: Union[pd.Series, np.ndarray],
values: Union[pd.Series, np.ndarray],
display_attributes: DisplayAttributes = None) -> None:
'''
Args:
name: Name to show in plot legend
'''
self.name = name
self.timestamps = series_to_array(timestamps)
self.values = series_to_array(values)
if display_attributes is None: display_attributes = LinePlotAttributes()
self.display_attributes = display_attributes
def __init__(self,
name,
bucket_names,
bucket_values,
proportional_widths=True,
show_means=True,
show_all=True,
show_outliers=False,
notched=False):
'''
Args:
name: name used for this data in a plot legend
bucket_names: list of strings used on x axis labels
bucket_values: list of numpy arrays that are summarized in this plot
proportional_widths: if set to True, the width each box in the boxplot will be proportional to the number of items in its corresponding array
show_means: Whether to display a marker where the mean is for each array
show_outliers: Whether to show markers for outliers that are outside the whiskers.
Box is at Q1 = 25%, Q3 = 75% quantiles, whiskers are at Q1 - 1.5 * (Q3 - Q1), Q3 + 1.5 * (Q3 - Q1)
notched: Whether to show notches indicating the confidence interval around the median
'''
assert isinstance(bucket_names, list) and isinstance(
bucket_values, list) and len(bucket_names) == len(bucket_values)
self.name = name
self.bucket_names = bucket_names
self.bucket_values = series_to_array(bucket_values)
self.plot_type = 'boxplot'
self.proportional_widths = proportional_widths
self.show_means = show_means
self.show_all = show_all
self.show_outliers = show_outliers
self.notched = notched
self.time_plot = False
def run_indicators(self,
indicator_names: Sequence[str] = None,
contract_groups: Sequence[ContractGroup] = None,
clear_all: bool = False) -> None:
'''Calculate values of the indicators specified and store them.
Args:
indicator_names: List of indicator names. If None (default) run all indicators
contract_groups: Contract group to run this indicator for. If None (default), we run it for all contract groups.
clear_all: If set, clears all indicator values before running. Default False.
'''
if indicator_names is None: indicator_names = list(self.indicators.keys())
if contract_groups is None: contract_groups = self.contract_groups
if clear_all: self.indicator_values = defaultdict(types.SimpleNamespace)
ind_names = []
for ind_name, cgroup_list in self.indicator_cgroups.items():
if len(set(contract_groups).intersection(cgroup_list)): ind_names.append(ind_name)
indicator_names = list(set(ind_names).intersection(indicator_names))
for cgroup in contract_groups:
cgroup_ind_namespace = self.indicator_values[cgroup]
for indicator_name in indicator_names:
# First run all parents
parent_names = self.indicator_deps[indicator_name]
for parent_name in parent_names:
if cgroup in self.indicator_values and hasattr(cgroup_ind_namespace, parent_name): continue
self.run_indicators([parent_name], [cgroup])
# Now run the actual indicator
if cgroup in self.indicator_values and hasattr(cgroup_ind_namespace, indicator_name): continue
indicator_function = self.indicators[indicator_name]
parent_values = types.SimpleNamespace()
for parent_name in parent_names:
setattr(parent_values, parent_name, getattr(cgroup_ind_namespace, parent_name))
if isinstance(indicator_function, np.ndarray) or isinstance(indicator_function, pd.Series):
indicator_values = indicator_function
else:
indicator_values = indicator_function(cgroup, self.timestamps, parent_values, self.strategy_context)
setattr(cgroup_ind_namespace, indicator_name, series_to_array(indicator_values))
def run_signals(self,
signal_names: Sequence[str] = None,
contract_groups: Sequence[ContractGroup] = None,
clear_all: bool = False) -> None:
'''Calculate values of the signals specified and store them.
Args:
signal_names: List of signal names. If None (default) run all signals
contract_groups: Contract groups to run this signal for. If None (default), we run it for all contract groups.
clear_all: If set, clears all signal values before running. Default False.
'''
if signal_names is None: signal_names = list(self.signals.keys())
if contract_groups is None: contract_groups = self.contract_groups
if clear_all: self.signal_values = defaultdict(types.SimpleNamespace)
sig_names = []
for sig_name, cgroup_list in self.signal_cgroups.items():
if len(set(contract_groups).intersection(cgroup_list)):
sig_names.append(sig_name)
signal_names = list(set(sig_names).intersection(signal_names))
for cgroup in contract_groups:
for signal_name in signal_names:
if cgroup not in self.signal_cgroups[signal_name]: continue
# First run all parent signals
parent_names = self.signal_deps[signal_name]
for parent_name in parent_names:
if cgroup in self.signal_values and hasattr(self.signal_values[cgroup], parent_name): continue
self.run_signals([parent_name], [cgroup])
# Now run the actual signal
if cgroup in self.signal_values and hasattr(self.signal_values[cgroup], signal_name): continue
signal_function = self.signals[signal_name]
parent_values = types.SimpleNamespace()
for parent_name in parent_names:
sig_vals = getattr(self.signal_values[cgroup], parent_name)
setattr(parent_values, parent_name, sig_vals)
# Get indicators needed for this signal
indicator_values = types.SimpleNamespace()
for indicator_name in self.signal_indicator_deps[signal_name]:
setattr(indicator_values, indicator_name, getattr(self.indicator_values[cgroup], indicator_name))
signal_output = signal_function(cgroup, self.timestamps, indicator_values, parent_values, self.strategy_context)
setattr(self.signal_values[cgroup], signal_name, series_to_array(signal_output))
def __init__(self, name: str,
bucket_names: Sequence[str],
bucket_values: Sequence[np.ndarray],
display_attributes: DisplayAttributes = None) -> None:
'''
Args:
name: name used for this data in a plot legend
bucket_names: list of strings used on x axis labels
bucket_values: list of numpy arrays that are summarized in this plot
'''
assert isinstance(bucket_names, list) and isinstance(bucket_values, list) and len(bucket_names) == len(bucket_values)
self.display_attributes = BoxPlotAttributes()
self.name = name
self.bucket_names = bucket_names
self.bucket_values = series_to_array(bucket_values)
if display_attributes is None: display_attributes = BoxPlotAttributes()
self.display_attributes = display_attributes
def add_indicator(self,
name: str,
indicator: IndicatorType,
contract_groups: Sequence[ContractGroup] = None,
depends_on: Sequence[str] = None) -> None:
'''
Args:
name: Name of the indicator
indicator: A function that takes strategy timestamps and other indicators and returns a numpy array
containing indicator values. The return array must have the same length as the timestamps object.
Can also be a numpy array or a pandas Series in which case we just store the values.
contract_groups: Contract groups that this indicator applies to. If not set, it applies to all contract groups. Default None.
depends_on: Names of other indicators that we need to compute this indicator. Default None.
'''
self.indicators[name] = indicator
self.indicator_deps[name] = [] if depends_on is None else list(depends_on)
if contract_groups is None: contract_groups = self.contract_groups
if isinstance(indicator, np.ndarray) or isinstance(indicator, pd.Series):
indicator_values = series_to_array(indicator)
for contract_group in contract_groups:
setattr(self.indicator_values[contract_group], name, indicator_values)
self.indicator_cgroups[name] = list(contract_groups)
