class Data(Wrapping, StatsBuilderMixin, PlotsBuilderMixin, metaclass=MetaData):
"""Class that downloads, updates, and manages data coming from a data source."""
def __init__(self,
wrapper: ArrayWrapper,
data: tp.Data,
tz_localize: tp.Optional[tp.TimezoneLike],
tz_convert: tp.Optional[tp.TimezoneLike],
missing_index: str,
missing_columns: str,
download_kwargs: dict,
**kwargs) -> None:
Wrapping.__init__(
self,
wrapper,
data=data,
tz_localize=tz_localize,
tz_convert=tz_convert,
missing_index=missing_index,
missing_columns=missing_columns,
download_kwargs=download_kwargs,
**kwargs
)
StatsBuilderMixin.__init__(self)
PlotsBuilderMixin.__init__(self)
checks.assert_instance_of(data, dict)
for k, v in data.items():
checks.assert_meta_equal(v, data[list(data.keys())[0]])
self._data = data
self._tz_localize = tz_localize
self._tz_convert = tz_convert
self._missing_index = missing_index
self._missing_columns = missing_columns
self._download_kwargs = download_kwargs
def indexing_func(self: DataT, pd_indexing_func: tp.PandasIndexingFunc, **kwargs) -> DataT:
"""Perform indexing on `Data`."""
new_wrapper = pd_indexing_func(self.wrapper)
new_data = {k: pd_indexing_func(v) for k, v in self.data.items()}
return self.replace(
wrapper=new_wrapper,
data=new_data
)
@property
def data(self) -> tp.Data:
"""Data dictionary keyed by symbol."""
return self._data
@property
def symbols(self) -> tp.List[tp.Label]:
"""List of symbols."""
return list(self.data.keys())
@property
def tz_localize(self) -> tp.Optional[tp.TimezoneLike]:
"""`tz_localize` initially passed to `Data.download_symbol`."""
return self._tz_localize
@property
def tz_convert(self) -> tp.Optional[tp.TimezoneLike]:
"""`tz_convert` initially passed to `Data.download_symbol`."""
return self._tz_convert
@property
def missing_index(self) -> str:
"""`missing_index` initially passed to `Data.download_symbol`."""
return self._missing_index
@property
def missing_columns(self) -> str:
"""`missing_columns` initially passed to `Data.download_symbol`."""
return self._missing_columns
@property
def download_kwargs(self) -> dict:
"""Keyword arguments initially passed to `Data.download_symbol`."""
return self._download_kwargs
@classmethod
def align_index(cls, data: tp.Data, missing: str = 'nan') -> tp.Data:
"""Align data to have the same index.
The argument `missing` accepts the following values:
* 'nan': set missing data points to NaN
* 'drop': remove missing data points
* 'raise': raise an error"""
if len(data) == 1:
return data
index = None
for k, v in data.items():
if index is None:
index = v.index
else:
if len(index.intersection(v.index)) != len(index.union(v.index)):
if missing == 'nan':
warnings.warn("Symbols have mismatching index. "
"Setting missing data points to NaN.", stacklevel=2)
index = index.union(v.index)
elif missing == 'drop':
warnings.warn("Symbols have mismatching index. "
"Dropping missing data points.", stacklevel=2)
index = index.intersection(v.index)
elif missing == 'raise':
raise ValueError("Symbols have mismatching index")
else:
raise ValueError(f"missing='{missing}' is not recognized")
# reindex
new_data = {k: v.reindex(index=index) for k, v in data.items()}
return new_data
@classmethod
def align_columns(cls, data: tp.Data, missing: str = 'raise') -> tp.Data:
"""Align data to have the same columns.
See `Data.align_index` for `missing`."""
if len(data) == 1:
return data
columns = None
multiple_columns = False
name_is_none = False
for k, v in data.items():
if isinstance(v, pd.Series):
if v.name is None:
name_is_none = True
v = v.to_frame()
else:
multiple_columns = True
if columns is None:
columns = v.columns
else:
if len(columns.intersection(v.columns)) != len(columns.union(v.columns)):
if missing == 'nan':
warnings.warn("Symbols have mismatching columns. "
"Setting missing data points to NaN.", stacklevel=2)
columns = columns.union(v.columns)
elif missing == 'drop':
warnings.warn("Symbols have mismatching columns. "
"Dropping missing data points.", stacklevel=2)
columns = columns.intersection(v.columns)
elif missing == 'raise':
raise ValueError("Symbols have mismatching columns")
else:
raise ValueError(f"missing='{missing}' is not recognized")
# reindex
new_data = {}
for k, v in data.items():
if isinstance(v, pd.Series):
v = v.to_frame(name=v.name)
v = v.reindex(columns=columns)
if not multiple_columns:
v = v[columns[0]]
if name_is_none:
v = v.rename(None)
new_data[k] = v
return new_data
@classmethod
def select_symbol_kwargs(cls, symbol: tp.Label, kwargs: dict) -> dict:
"""Select keyword arguments belonging to `symbol`."""
_kwargs = dict()
for k, v in kwargs.items():
if isinstance(v, symbol_dict):
if symbol in v:
_kwargs[k] = v[symbol]
else:
_kwargs[k] = v
return _kwargs
@classmethod
def from_data(cls: tp.Type[DataT],
data: tp.Data,
tz_localize: tp.Optional[tp.TimezoneLike] = None,
tz_convert: tp.Optional[tp.TimezoneLike] = None,
missing_index: tp.Optional[str] = None,
missing_columns: tp.Optional[str] = None,
wrapper_kwargs: tp.KwargsLike = None,
**kwargs) -> DataT:
"""Create a new `Data` instance from (aligned) data.
Args:
data (dict): Dictionary of array-like objects keyed by symbol.
tz_localize (timezone_like): If the index is tz-naive, convert to a timezone.
See `vectorbt.utils.datetime_.to_timezone`.
tz_convert (timezone_like): Convert the index from one timezone to another.
See `vectorbt.utils.datetime_.to_timezone`.
missing_index (str): See `Data.align_index`.
missing_columns (str): See `Data.align_columns`.
wrapper_kwargs (dict): Keyword arguments passed to `vectorbt.base.array_wrapper.ArrayWrapper`.
**kwargs: Keyword arguments passed to the `__init__` method.
For defaults, see `data` in `vectorbt._settings.settings`."""
from vectorbt._settings import settings
data_cfg = settings['data']
# Get global defaults
if tz_localize is None:
tz_localize = data_cfg['tz_localize']
if tz_convert is None:
tz_convert = data_cfg['tz_convert']
if missing_index is None:
missing_index = data_cfg['missing_index']
if missing_columns is None:
missing_columns = data_cfg['missing_columns']
if wrapper_kwargs is None:
wrapper_kwargs = {}
data = data.copy()
for k, v in data.items():
# Convert array to pandas
if not isinstance(v, (pd.Series, pd.DataFrame)):
v = np.asarray(v)
if v.ndim == 1:
v = pd.Series(v)
else:
v = pd.DataFrame(v)
# Perform operations with datetime-like index
if isinstance(v.index, pd.DatetimeIndex):
if tz_localize is not None:
if not is_tz_aware(v.index):
v = v.tz_localize(to_timezone(tz_localize))
if tz_convert is not None:
v = v.tz_convert(to_timezone(tz_convert))
v.index.freq = v.index.inferred_freq
data[k] = v
# Align index and columns
data = cls.align_index(data, missing=missing_index)
data = cls.align_columns(data, missing=missing_columns)
# Create new instance
symbols = list(data.keys())
wrapper = ArrayWrapper.from_obj(data[symbols[0]], **wrapper_kwargs)
return cls(
wrapper,
data,
tz_localize=tz_localize,
tz_convert=tz_convert,
missing_index=missing_index,
missing_columns=missing_columns,
**kwargs
)
@classmethod
def download_symbol(cls, symbol: tp.Label, **kwargs) -> tp.SeriesFrame:
"""Abstract method to download a symbol."""
raise NotImplementedError
@classmethod
def download(cls: tp.Type[DataT],
symbols: tp.Union[tp.Label, tp.Labels],
tz_localize: tp.Optional[tp.TimezoneLike] = None,
tz_convert: tp.Optional[tp.TimezoneLike] = None,
missing_index: tp.Optional[str] = None,
missing_columns: tp.Optional[str] = None,
wrapper_kwargs: tp.KwargsLike = None,
**kwargs) -> DataT:
"""Download data using `Data.download_symbol`.
Args:
symbols (hashable or sequence of hashable): One or multiple symbols.
!!! note
Tuple is considered as a single symbol (since hashable).
tz_localize (any): See `Data.from_data`.
tz_convert (any): See `Data.from_data`.
missing_index (str): See `Data.from_data`.
missing_columns (str): See `Data.from_data`.
wrapper_kwargs (dict): See `Data.from_data`.
**kwargs: Passed to `Data.download_symbol`.
If two symbols require different keyword arguments, pass `symbol_dict` for each argument.
"""
if checks.is_hashable(symbols):
symbols = [symbols]
elif not checks.is_sequence(symbols):
raise TypeError("Symbols must be either hashable or sequence of hashable")
data = dict()
for s in symbols:
# Select keyword arguments for this symbol
_kwargs = cls.select_symbol_kwargs(s, kwargs)
# Download data for this symbol
data[s] = cls.download_symbol(s, **_kwargs)
# Create new instance from data
return cls.from_data(
data,
tz_localize=tz_localize,
tz_convert=tz_convert,
missing_index=missing_index,
missing_columns=missing_columns,
wrapper_kwargs=wrapper_kwargs,
download_kwargs=kwargs
)
def update_symbol(self, symbol: tp.Label, **kwargs) -> tp.SeriesFrame:
"""Abstract method to update a symbol."""
raise NotImplementedError
def update(self: DataT, **kwargs) -> DataT:
"""Update the data using `Data.update_symbol`.
Args:
**kwargs: Passed to `Data.update_symbol`.
If two symbols require different keyword arguments, pass `symbol_dict` for each argument.
!!! note
Returns a new `Data` instance."""
new_data = dict()
for k, v in self.data.items():
# Select keyword arguments for this symbol
_kwargs = self.select_symbol_kwargs(k, kwargs)
# Download new data for this symbol
new_obj = self.update_symbol(k, **_kwargs)
# Convert array to pandas
if not isinstance(new_obj, (pd.Series, pd.DataFrame)):
new_obj = np.asarray(new_obj)
index = pd.RangeIndex(
start=v.index[-1],
stop=v.index[-1] + new_obj.shape[0],
step=1
)
if new_obj.ndim == 1:
new_obj = pd.Series(new_obj, index=index)
else:
new_obj = pd.DataFrame(new_obj, index=index)
# Perform operations with datetime-like index
if isinstance(new_obj.index, pd.DatetimeIndex):
if self.tz_localize is not None:
if not is_tz_aware(new_obj.index):
new_obj = new_obj.tz_localize(to_timezone(self.tz_localize))
if self.tz_convert is not None:
new_obj = new_obj.tz_convert(to_timezone(self.tz_convert))
new_data[k] = new_obj
# Align index and columns
new_data = self.align_index(new_data, missing=self.missing_index)
new_data = self.align_columns(new_data, missing=self.missing_columns)
# Concatenate old and new data
for k, v in new_data.items():
if isinstance(self.data[k], pd.Series):
if isinstance(v, pd.DataFrame):
v = v[self.data[k].name]
else:
v = v[self.data[k].columns]
v = pd.concat((self.data[k], v), axis=0)
v = v[~v.index.duplicated(keep='last')]
if isinstance(v.index, pd.DatetimeIndex):
v.index.freq = v.index.inferred_freq
new_data[k] = v
# Create new instance
new_index = new_data[self.symbols[0]].index
return self.replace(
wrapper=self.wrapper.replace(index=new_index),
data=new_data
)
@cached_method
def concat(self, level_name: str = 'symbol') -> tp.Data:
"""Return a dict of Series/DataFrames with symbols as columns, keyed by column name."""
first_data = self.data[self.symbols[0]]
index = first_data.index
if isinstance(first_data, pd.Series):
columns = pd.Index([first_data.name])
else:
columns = first_data.columns
if len(self.symbols) > 1:
new_data = {c: pd.DataFrame(
index=index,
columns=pd.Index(self.symbols, name=level_name)
) for c in columns}
else:
new_data = {c: pd.Series(
index=index,
name=self.symbols[0]
) for c in columns}
for c in columns:
for s in self.symbols:
if isinstance(self.data[s], pd.Series):
col_data = self.data[s]
else:
col_data = self.data[s][c]
if len(self.symbols) > 1:
new_data[c].loc[:, s] = col_data
else:
new_data[c].loc[:] = col_data
return new_data
def get(self, column: tp.Optional[tp.Label] = None, **kwargs) -> tp.MaybeTuple[tp.SeriesFrame]:
"""Get column data.
If one symbol, returns data for that symbol.
If multiple symbols, performs concatenation first and returns a DataFrame if one column
and a tuple of DataFrames if a list of columns passed."""
if len(self.symbols) == 1:
if column is None:
return self.data[self.symbols[0]]
return self.data[self.symbols[0]][column]
concat_data = self.concat(**kwargs)
if len(concat_data) == 1:
return tuple(concat_data.values())[0]
if column is not None:
if isinstance(column, list):
return tuple([concat_data[c] for c in column])
return concat_data[column]
return tuple(concat_data.values())
# ############# Stats ############# #
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `Data.stats`.
Merges `vectorbt.generic.stats_builder.StatsBuilderMixin.stats_defaults` and
`data.stats` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
data_stats_cfg = settings['data']['stats']
return merge_dicts(
StatsBuilderMixin.stats_defaults.__get__(self),
data_stats_cfg
)
_metrics: tp.ClassVar[Config] = Config(
dict(
start=dict(
title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'
),
end=dict(
title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'
),
period=dict(
title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper'
),
total_symbols=dict(
title='Total Symbols',
calc_func=lambda self: len(self.symbols),
agg_func=None,
tags='data'
),
null_counts=dict(
title='Null Counts',
calc_func=lambda self, group_by:
{
k: v.isnull().vbt(wrapper=self.wrapper).sum(group_by=group_by)
for k, v in self.data.items()
},
tags='data'
)
),
copy_kwargs=dict(copy_mode='deep')
)
@property
def metrics(self) -> Config:
return self._metrics
# ############# Plotting ############# #
def plot(self,
column: tp.Optional[tp.Label] = None,
base: tp.Optional[float] = None,
**kwargs) -> tp.Union[tp.BaseFigure, plotting.Scatter]: # pragma: no cover
"""Plot orders.
Args:
column (str): Name of the column to plot.
base (float): Rebase all series of a column to a given intial base.
!!! note
The column should contain prices.
kwargs (dict): Keyword arguments passed to `vectorbt.generic.accessors.GenericAccessor.plot`.
## Example
```python-repl
>>> import vectorbt as vbt
>>> start = '2021-01-01 UTC' # crypto is in UTC
>>> end = '2021-06-01 UTC'
>>> data = vbt.YFData.download(['BTC-USD', 'ETH-USD', 'ADA-USD'], start=start, end=end)
>>> data.plot(column='Close', base=1)
```
"""
self_col = self.select_one(column=column, group_by=False)
data = self_col.get()
if base is not None:
data = data.vbt.rebase(base)
return data.vbt.plot(**kwargs)
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `Data.plots`.
Merges `vectorbt.generic.plots_builder.PlotsBuilderMixin.plots_defaults` and
`data.plots` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
data_plots_cfg = settings['data']['plots']
return merge_dicts(
PlotsBuilderMixin.plots_defaults.__get__(self),
data_plots_cfg
)
_subplots: tp.ClassVar[Config] = Config(
dict(
plot=dict(
check_is_not_grouped=True,
plot_func='plot',
pass_add_trace_kwargs=True,
tags='data'
)
),
copy_kwargs=dict(copy_mode='deep')
)
@property
def subplots(self) -> Config:
return self._subplots
from vectorbt.records.mapped_array import MappedArray
from vectorbt.utils.colors import adjust_lightness
from vectorbt.utils.config import merge_dicts, Config
from vectorbt.utils.decorators import cached_property, cached_method
from vectorbt.utils.figure import make_figure, get_domain
from vectorbt.utils.template import RepEval
__pdoc__ = {}
dd_field_config = Config(dict(dtype=drawdown_dt,
settings=dict(
id=dict(title='Drawdown Id'),
peak_idx=dict(title='Peak Timestamp',
mapping='index'),
valley_idx=dict(title='Valley Timestamp',
mapping='index'),
peak_val=dict(title='Peak Value', ),
valley_val=dict(title='Valley Value', ),
end_val=dict(title='End Value', ),
status=dict(mapping=DrawdownStatus))),
readonly=True,
as_attrs=False)
"""_"""
__pdoc__['dd_field_config'] = f"""Field config for `Drawdowns`.
```json
{dd_field_config.to_doc()}
```
"""
class StatsBuilderMixin(metaclass=MetaStatsBuilderMixin):
"""Mixin that implements `StatsBuilderMixin.stats`.
Required to be a subclass of `vectorbt.base.array_wrapper.Wrapping`."""
def __init__(self) -> None:
checks.assert_instance_of(self, Wrapping)
# Copy writeable attrs
self._metrics = self.__class__._metrics.copy()
@property
def writeable_attrs(self) -> tp.Set[str]:
"""Set of writeable attributes that will be saved/copied along with the config."""
return {'_metrics'}
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `StatsBuilderMixin.stats`.
See `stats_builder` in `vectorbt._settings.settings`."""
from vectorbt._settings import settings
stats_builder_cfg = settings['stats_builder']
return merge_dicts(stats_builder_cfg,
dict(settings=dict(freq=self.wrapper.freq)))
_metrics: tp.ClassVar[Config] = Config(dict(
start=dict(title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'),
end=dict(title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'),
period=dict(title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper')),
copy_kwargs=dict(copy_mode='deep'))
@property
def metrics(self) -> Config:
"""Metrics supported by `${cls_name}`.
```json
${metrics}
```
Returns `${cls_name}._metrics`, which gets (deep) copied upon creation of each instance.
Thus, changing this config won't affect the class.
To change metrics, you can either change the config in-place, override this property,
or overwrite the instance variable `${cls_name}._metrics`."""
return self._metrics
def stats(
self,
metrics: tp.Optional[tp.MaybeIterable[tp.Union[str, tp.Tuple[
str, tp.Kwargs]]]] = None,
tags: tp.Optional[tp.MaybeIterable[str]] = None,
column: tp.Optional[tp.Label] = None,
group_by: tp.GroupByLike = None,
agg_func: tp.Optional[tp.Callable] = np.mean,
silence_warnings: tp.Optional[bool] = None,
template_mapping: tp.Optional[tp.Mapping] = None,
settings: tp.KwargsLike = None,
filters: tp.KwargsLike = None,
metric_settings: tp.KwargsLike = None
) -> tp.Optional[tp.SeriesFrame]:
"""Compute various metrics on this object.
Args:
metrics (str, tuple, iterable, or dict): Metrics to calculate.
Each element can be either:
* a metric name (see keys in `StatsBuilderMixin.metrics`)
* a tuple of a metric name and a settings dict as in `StatsBuilderMixin.metrics`.
The settings dict can contain the following keys:
* `title`: Title of the metric. Defaults to the name.
* `tags`: Single or multiple tags to associate this metric with.
If any of these tags is in `tags`, keeps this metric.
* `check_{filter}` and `inv_check_{filter}`: Whether to check this metric against a
filter defined in `filters`. True (or False for inverse) means to keep this metric.
* `calc_func` (required): Calculation function for custom metrics.
Should return either a scalar for one column/group, pd.Series for multiple columns/groups,
or a dict of such for multiple sub-metrics.
* `resolve_calc_func`: whether to resolve `calc_func`. If the function can be accessed
by traversing attributes of this object, you can specify the path to this function
as a string (see `vectorbt.utils.attr_.deep_getattr` for the path format).
If `calc_func` is a function, arguments from merged metric settings are matched with
arguments in the signature (see below). If `resolve_calc_func` is False, `calc_func`
should accept (resolved) self and dictionary of merged metric settings.
Defaults to True.
* `post_calc_func`: Function to post-process the result of `calc_func`.
Should accept (resolved) self, output of `calc_func`, and dictionary of merged metric settings,
and return whatever is acceptable to be returned by `calc_func`. Defaults to None.
* `fill_wrap_kwargs`: Whether to fill `wrap_kwargs` with `to_timedelta` and `silence_warnings`.
Defaults to False.
* `apply_to_timedelta`: Whether to apply `vectorbt.base.array_wrapper.ArrayWrapper.to_timedelta`
on the result. To disable this globally, pass `to_timedelta=False` in `settings`.
Defaults to False.
* `pass_{arg}`: Whether to pass any argument from the settings (see below). Defaults to True if
this argument was found in the function's signature. Set to False to not pass.
If argument to be passed was not found, `pass_{arg}` is removed.
* `resolve_path_{arg}`: Whether to resolve an argument that is meant to be an attribute of
this object and is the first part of the path of `calc_func`. Passes only optional arguments.
Defaults to True. See `vectorbt.utils.attr_.AttrResolver.resolve_attr`.
* `resolve_{arg}`: Whether to resolve an argument that is meant to be an attribute of
this object and is present in the function's signature. Defaults to False.
See `vectorbt.utils.attr_.AttrResolver.resolve_attr`.
* `template_mapping`: Mapping to replace templates in metric settings. Used across all settings.
* Any other keyword argument that overrides the settings or is passed directly to `calc_func`.
If `resolve_calc_func` is True, the calculation function may "request" any of the
following arguments by accepting them or if `pass_{arg}` was found in the settings dict:
* Each of `vectorbt.utils.attr_.AttrResolver.self_aliases`: original object
(ungrouped, with no column selected)
* `group_by`: won't be passed if it was used in resolving the first attribute of `calc_func`
specified as a path, use `pass_group_by=True` to pass anyway
* `column`
* `metric_name`
* `agg_func`
* `silence_warnings`
* `to_timedelta`: replaced by True if None and frequency is set
* Any argument from `settings`
* Any attribute of this object if it meant to be resolved
(see `vectorbt.utils.attr_.AttrResolver.resolve_attr`)
Pass `metrics='all'` to calculate all supported metrics.
tags (str or iterable): Tags to select.
See `vectorbt.utils.tags.match_tags`.
column (str): Name of the column/group.
!!! hint
There are two ways to select a column: `obj['a'].stats()` and `obj.stats(column='a')`.
They both accomplish the same thing but in different ways: `obj['a'].stats()` computes
statistics of the column 'a' only, while `obj.stats(column='a')` computes statistics of
all columns first and only then selects the column 'a'. The first method is preferred
when you have a lot of data or caching is disabled. The second method is preferred when
most attributes have already been cached.
group_by (any): Group or ungroup columns. See `vectorbt.base.column_grouper.ColumnGrouper`.
agg_func (callable): Aggregation function to aggregate statistics across all columns.
Defaults to mean.
Should take `pd.Series` and return a const.
Has only effect if `column` was specified or this object contains only one column of data.
If `agg_func` has been overridden by a metric:
* it only takes effect if global `agg_func` is not None
* will raise a warning if it's None but the result of calculation has multiple values
silence_warnings (bool): Whether to silence all warnings.
template_mapping (mapping): Global mapping to replace templates.
Gets merged over `template_mapping` from `StatsBuilderMixin.stats_defaults`.
Applied on `settings` and then on each metric settings.
filters (dict): Filters to apply.
Each item consists of the filter name and settings dict.
The settings dict can contain the following keys:
* `filter_func`: Filter function that should accept resolved self and
merged settings for a metric, and return either True or False.
* `warning_message`: Warning message to be shown when skipping a metric.
Can be a template that will be substituted using merged metric settings as mapping.
Defaults to None.
* `inv_warning_message`: Same as `warning_message` but for inverse checks.
Gets merged over `filters` from `StatsBuilderMixin.stats_defaults`.
settings (dict): Global settings and resolution arguments.
Extends/overrides `settings` from `StatsBuilderMixin.stats_defaults`.
Gets extended/overridden by metric settings.
metric_settings (dict): Keyword arguments for each metric.
Extends/overrides all global and metric settings.
For template logic, see `vectorbt.utils.template`.
For defaults, see `StatsBuilderMixin.stats_defaults`.
!!! hint
There are two types of arguments: optional (or resolution) and mandatory arguments.
Optional arguments are only passed if they are found in the function's signature.
Mandatory arguments are passed regardless of this. Optional arguments can only be defined
using `settings` (that is, globally), while mandatory arguments can be defined both using
default metric settings and `{metric_name}_kwargs`. Overriding optional arguments using default
metric settings or `{metric_name}_kwargs` won't turn them into mandatory. For this, pass `pass_{arg}=True`.
!!! hint
Make sure to resolve and then to re-use as many object attributes as possible to
utilize built-in caching (even if global caching is disabled).
## Example
See `vectorbt.portfolio.base` for examples.
"""
# Resolve defaults
if silence_warnings is None:
silence_warnings = self.stats_defaults.get('silence_warnings',
False)
template_mapping = merge_dicts(
self.stats_defaults.get('template_mapping', {}), template_mapping)
filters = merge_dicts(self.stats_defaults.get('filters', {}), filters)
settings = merge_dicts(self.stats_defaults.get('settings', {}),
settings)
metric_settings = merge_dicts(
self.stats_defaults.get('metric_settings', {}), metric_settings)
# Replace templates globally (not used at metric level)
if len(template_mapping) > 0:
sub_settings = deep_substitute(settings, mapping=template_mapping)
else:
sub_settings = settings
# Resolve self
reself = self.resolve_self(cond_kwargs=sub_settings,
impacts_caching=False,
silence_warnings=silence_warnings)
# Prepare metrics
if metrics is None:
metrics = reself.stats_defaults.get('metrics', 'all')
if metrics == 'all':
metrics = reself.metrics
if isinstance(metrics, dict):
metrics = list(metrics.items())
if isinstance(metrics, (str, tuple)):
metrics = [metrics]
# Prepare tags
if tags is None:
tags = reself.stats_defaults.get('tags', 'all')
if isinstance(tags, str) and tags == 'all':
tags = None
if isinstance(tags, (str, tuple)):
tags = [tags]
# Bring to the same shape
new_metrics = []
for i, metric in enumerate(metrics):
if isinstance(metric, str):
metric = (metric, reself.metrics[metric])
if not isinstance(metric, tuple):
raise TypeError(
f"Metric at index {i} must be either a string or a tuple")
new_metrics.append(metric)
metrics = new_metrics
# Handle duplicate names
metric_counts = Counter(list(map(lambda x: x[0], metrics)))
metric_i = {k: -1 for k in metric_counts.keys()}
metrics_dct = {}
for i, (metric_name, _metric_settings) in enumerate(metrics):
if metric_counts[metric_name] > 1:
metric_i[metric_name] += 1
metric_name = metric_name + '_' + str(metric_i[metric_name])
metrics_dct[metric_name] = _metric_settings
# Check metric_settings
missed_keys = set(metric_settings.keys()).difference(
set(metrics_dct.keys()))
if len(missed_keys) > 0:
raise ValueError(
f"Keys {missed_keys} in metric_settings could not be matched with any metric"
)
# Merge settings
opt_arg_names_dct = {}
custom_arg_names_dct = {}
resolved_self_dct = {}
mapping_dct = {}
for metric_name, _metric_settings in list(metrics_dct.items()):
opt_settings = merge_dicts(
{name: reself
for name in reself.self_aliases},
dict(column=column,
group_by=group_by,
metric_name=metric_name,
agg_func=agg_func,
silence_warnings=silence_warnings,
to_timedelta=None), settings)
_metric_settings = _metric_settings.copy()
passed_metric_settings = metric_settings.get(metric_name, {})
merged_settings = merge_dicts(opt_settings, _metric_settings,
passed_metric_settings)
metric_template_mapping = merged_settings.pop(
'template_mapping', {})
template_mapping_merged = merge_dicts(template_mapping,
metric_template_mapping)
template_mapping_merged = deep_substitute(template_mapping_merged,
mapping=merged_settings)
mapping = merge_dicts(template_mapping_merged, merged_settings)
merged_settings = deep_substitute(merged_settings, mapping=mapping)
# Filter by tag
if tags is not None:
in_tags = merged_settings.get('tags', None)
if in_tags is None or not match_tags(tags, in_tags):
metrics_dct.pop(metric_name, None)
continue
custom_arg_names = set(_metric_settings.keys()).union(
set(passed_metric_settings.keys()))
opt_arg_names = set(opt_settings.keys())
custom_reself = reself.resolve_self(
cond_kwargs=merged_settings,
custom_arg_names=custom_arg_names,
impacts_caching=True,
silence_warnings=merged_settings['silence_warnings'])
metrics_dct[metric_name] = merged_settings
custom_arg_names_dct[metric_name] = custom_arg_names
opt_arg_names_dct[metric_name] = opt_arg_names
resolved_self_dct[metric_name] = custom_reself
mapping_dct[metric_name] = mapping
# Filter metrics
for metric_name, _metric_settings in list(metrics_dct.items()):
custom_reself = resolved_self_dct[metric_name]
mapping = mapping_dct[metric_name]
_silence_warnings = _metric_settings.get('silence_warnings')
metric_filters = set()
for k in _metric_settings.keys():
filter_name = None
if k.startswith('check_'):
filter_name = k[len('check_'):]
elif k.startswith('inv_check_'):
filter_name = k[len('inv_check_'):]
if filter_name is not None:
if filter_name not in filters:
raise ValueError(
f"Metric '{metric_name}' requires filter '{filter_name}'"
)
metric_filters.add(filter_name)
for filter_name in metric_filters:
filter_settings = filters[filter_name]
_filter_settings = deep_substitute(filter_settings,
mapping=mapping)
filter_func = _filter_settings['filter_func']
warning_message = _filter_settings.get('warning_message', None)
inv_warning_message = _filter_settings.get(
'inv_warning_message', None)
to_check = _metric_settings.get('check_' + filter_name, False)
inv_to_check = _metric_settings.get('inv_check_' + filter_name,
False)
if to_check or inv_to_check:
whether_true = filter_func(custom_reself, _metric_settings)
to_remove = (to_check
and not whether_true) or (inv_to_check
and whether_true)
if to_remove:
if to_check and warning_message is not None and not _silence_warnings:
warnings.warn(warning_message)
if inv_to_check and inv_warning_message is not None and not _silence_warnings:
warnings.warn(inv_warning_message)
metrics_dct.pop(metric_name, None)
custom_arg_names_dct.pop(metric_name, None)
opt_arg_names_dct.pop(metric_name, None)
resolved_self_dct.pop(metric_name, None)
mapping_dct.pop(metric_name, None)
break
# Any metrics left?
if len(metrics_dct) == 0:
if not silence_warnings:
warnings.warn("No metrics to calculate", stacklevel=2)
return None
# Compute stats
arg_cache_dct = {}
stats_dct = {}
used_agg_func = False
for i, (metric_name,
_metric_settings) in enumerate(metrics_dct.items()):
try:
final_kwargs = _metric_settings.copy()
opt_arg_names = opt_arg_names_dct[metric_name]
custom_arg_names = custom_arg_names_dct[metric_name]
custom_reself = resolved_self_dct[metric_name]
# Clean up keys
for k, v in list(final_kwargs.items()):
if k.startswith('check_') or k.startswith(
'inv_check_') or k in ('tags', ):
final_kwargs.pop(k, None)
# Get metric-specific values
_column = final_kwargs.get('column')
_group_by = final_kwargs.get('group_by')
_agg_func = final_kwargs.get('agg_func')
_silence_warnings = final_kwargs.get('silence_warnings')
if final_kwargs['to_timedelta'] is None:
final_kwargs[
'to_timedelta'] = custom_reself.wrapper.freq is not None
to_timedelta = final_kwargs.get('to_timedelta')
title = final_kwargs.pop('title', metric_name)
calc_func = final_kwargs.pop('calc_func')
resolve_calc_func = final_kwargs.pop('resolve_calc_func', True)
post_calc_func = final_kwargs.pop('post_calc_func', None)
use_caching = final_kwargs.pop('use_caching', True)
fill_wrap_kwargs = final_kwargs.pop('fill_wrap_kwargs', False)
if fill_wrap_kwargs:
final_kwargs['wrap_kwargs'] = merge_dicts(
dict(to_timedelta=to_timedelta,
silence_warnings=_silence_warnings),
final_kwargs.get('wrap_kwargs', None))
apply_to_timedelta = final_kwargs.pop('apply_to_timedelta',
False)
# Resolve calc_func
if resolve_calc_func:
if not callable(calc_func):
passed_kwargs_out = {}
def _getattr_func(
obj: tp.Any,
attr: str,
args: tp.ArgsLike = None,
kwargs: tp.KwargsLike = None,
call_attr: bool = True,
_final_kwargs: tp.Kwargs = final_kwargs,
_opt_arg_names: tp.Set[str] = opt_arg_names,
_custom_arg_names: tp.Set[str] = custom_arg_names,
_arg_cache_dct: tp.Kwargs = arg_cache_dct
) -> tp.Any:
if attr in final_kwargs:
return final_kwargs[attr]
if args is None:
args = ()
if kwargs is None:
kwargs = {}
if obj is custom_reself and _final_kwargs.pop(
'resolve_path_' + attr, True):
if call_attr:
return custom_reself.resolve_attr(
attr,
args=args,
cond_kwargs={
k: v
for k, v in _final_kwargs.items()
if k in _opt_arg_names
},
kwargs=kwargs,
custom_arg_names=_custom_arg_names,
cache_dct=_arg_cache_dct,
use_caching=use_caching,
passed_kwargs_out=passed_kwargs_out)
return getattr(obj, attr)
out = getattr(obj, attr)
if callable(out) and call_attr:
return out(*args, **kwargs)
return out
calc_func = custom_reself.deep_getattr(
calc_func,
getattr_func=_getattr_func,
call_last_attr=False)
if 'group_by' in passed_kwargs_out:
if 'pass_group_by' not in final_kwargs:
final_kwargs.pop('group_by', None)
# Resolve arguments
if callable(calc_func):
func_arg_names = get_func_arg_names(calc_func)
for k in func_arg_names:
if k not in final_kwargs:
if final_kwargs.pop('resolve_' + k, False):
try:
arg_out = custom_reself.resolve_attr(
k,
cond_kwargs=final_kwargs,
custom_arg_names=custom_arg_names,
cache_dct=arg_cache_dct,
use_caching=use_caching)
except AttributeError:
continue
final_kwargs[k] = arg_out
for k in list(final_kwargs.keys()):
if k in opt_arg_names:
if 'pass_' + k in final_kwargs:
if not final_kwargs.get(
'pass_' + k): # first priority
final_kwargs.pop(k, None)
elif k not in func_arg_names: # second priority
final_kwargs.pop(k, None)
for k in list(final_kwargs.keys()):
if k.startswith('pass_') or k.startswith(
'resolve_'):
final_kwargs.pop(k, None) # cleanup
# Call calc_func
out = calc_func(**final_kwargs)
else:
# calc_func is already a result
out = calc_func
else:
# Do not resolve calc_func
out = calc_func(custom_reself, _metric_settings)
# Call post_calc_func
if post_calc_func is not None:
out = post_calc_func(custom_reself, out, _metric_settings)
# Post-process and store the metric
multiple = True
if not isinstance(out, dict):
multiple = False
out = {None: out}
for k, v in out.items():
# Resolve title
if multiple:
if title is None:
t = str(k)
else:
t = title + ': ' + str(k)
else:
t = title
# Check result type
if checks.is_any_array(v) and not checks.is_series(v):
raise TypeError(
"calc_func must return either a scalar for one column/group, "
"pd.Series for multiple columns/groups, or a dict of such. "
f"Not {type(v)}.")
# Handle apply_to_timedelta
if apply_to_timedelta and to_timedelta:
v = custom_reself.wrapper.to_timedelta(
v, silence_warnings=_silence_warnings)
# Select column or aggregate
if checks.is_series(v):
if _column is not None:
v = custom_reself.select_one_from_obj(
v,
custom_reself.wrapper.regroup(_group_by),
column=_column)
elif _agg_func is not None and agg_func is not None:
v = _agg_func(v)
used_agg_func = True
elif _agg_func is None and agg_func is not None:
if not _silence_warnings:
warnings.warn(
f"Metric '{metric_name}' returned multiple values "
f"despite having no aggregation function",
stacklevel=2)
continue
# Store metric
if t in stats_dct:
if not _silence_warnings:
warnings.warn(f"Duplicate metric title '{t}'",
stacklevel=2)
stats_dct[t] = v
except Exception as e:
warnings.warn(f"Metric '{metric_name}' raised an exception",
stacklevel=2)
raise e
# Return the stats
if reself.wrapper.get_ndim(group_by=group_by) == 1:
return pd.Series(stats_dct,
name=reself.wrapper.get_name(group_by=group_by))
if column is not None:
return pd.Series(stats_dct, name=column)
if agg_func is not None:
if used_agg_func and not silence_warnings:
warnings.warn(
f"Object has multiple columns. Aggregating using {agg_func}. "
f"Pass column to select a single column/group.",
stacklevel=2)
return pd.Series(stats_dct, name='agg_func_' + agg_func.__name__)
new_index = reself.wrapper.grouper.get_columns(group_by=group_by)
stats_df = pd.DataFrame(stats_dct, index=new_index)
return stats_df
# ############# Docs ############# #
@classmethod
def build_metrics_doc(cls, source_cls: tp.Optional[type] = None) -> str:
"""Build metrics documentation."""
if source_cls is None:
source_cls = StatsBuilderMixin
return string.Template(
inspect.cleandoc(get_dict_attr(source_cls,
'metrics').__doc__)).substitute({
'metrics':
cls.metrics.to_doc(),
'cls_name':
cls.__name__
})
@classmethod
def override_metrics_doc(cls,
__pdoc__: dict,
source_cls: tp.Optional[type] = None) -> None:
"""Call this method on each subclass that overrides `metrics`."""
__pdoc__[cls.__name__ +
'.metrics'] = cls.build_metrics_doc(source_cls=source_cls)
```
Changes take effect immediately."""
import json
from vectorbt.utils.config import Config
__pdoc__ = {}
# Color schema
color_schema = Config(blue="#1f77b4",
orange="#ff7f0e",
green="#2ca02c",
red="#dc3912",
purple="#9467bd",
brown="#8c564b",
pink="#e377c2",
gray="#7f7f7f",
yellow="#bcbd22",
cyan="#17becf")
"""_"""
__pdoc__['color_schema'] = f"""Color schema.
```plaintext
{json.dumps(color_schema, indent=2)}
```
"""
# Contrast color schema
contrast_color_schema = Config(blue='#4285F4',
0 False False
1 True False
2 False True
3 True False
4 False True
```
"""
pass
setattr(RPROB, '__doc__', _RPROB.__doc__)
rprobex_config = Config(
dict(class_name='RPROBEX',
module_name=__name__,
short_name='rprobex',
param_names=['prob'],
exit_only=True,
iteratively=False))
"""Factory config for `RPROBEX`."""
rprobex_func_config = Config(
dict(exit_choice_func=rand_by_prob_choice_nb,
exit_settings=dict(pass_params=['prob'],
pass_kwargs=['first', 'temp_idx_arr', 'flex_2d']),
pass_flex_2d=True,
param_settings=dict(prob=flex_elem_param_config),
seed=None))
"""Exit function config for `RPROBEX`."""
RPROBEX = SignalFactory(**rprobex_config).from_choice_func(
class Ranges(Records):
"""Extends `Records` for working with range records.
Requires `records_arr` to have all fields defined in `vectorbt.generic.enums.range_dt`."""
@property
def field_config(self) -> Config:
return self._field_config
def __init__(self,
wrapper: ArrayWrapper,
records_arr: tp.RecordArray,
ts: tp.Optional[tp.ArrayLike] = None,
**kwargs) -> None:
Records.__init__(self, wrapper, records_arr, ts=ts, **kwargs)
self._ts = ts
def indexing_func(self: RangesT, pd_indexing_func: tp.PandasIndexingFunc,
**kwargs) -> RangesT:
"""Perform indexing on `Ranges`."""
new_wrapper, new_records_arr, _, col_idxs = \
Records.indexing_func_meta(self, pd_indexing_func, **kwargs)
if self.ts is not None:
new_ts = new_wrapper.wrap(self.ts.values[:, col_idxs],
group_by=False)
else:
new_ts = None
return self.replace(wrapper=new_wrapper,
records_arr=new_records_arr,
ts=new_ts)
@classmethod
def from_ts(cls: tp.Type[RangesT],
ts: tp.ArrayLike,
gap_value: tp.Optional[tp.Scalar] = None,
attach_ts: bool = True,
wrapper_kwargs: tp.KwargsLike = None,
**kwargs) -> RangesT:
"""Build `Ranges` from time series `ts`.
Searches for sequences of
* True values in boolean data (False acts as a gap),
* positive values in integer data (-1 acts as a gap), and
* non-NaN values in any other data (NaN acts as a gap).
`**kwargs` will be passed to `Ranges.__init__`."""
if wrapper_kwargs is None:
wrapper_kwargs = {}
ts_pd = to_pd_array(ts)
ts_arr = to_2d_array(ts_pd)
if gap_value is None:
if np.issubdtype(ts_arr.dtype, np.bool_):
gap_value = False
elif np.issubdtype(ts_arr.dtype, np.integer):
gap_value = -1
else:
gap_value = np.nan
records_arr = nb.find_ranges_nb(ts_arr, gap_value)
wrapper = ArrayWrapper.from_obj(ts_pd, **wrapper_kwargs)
return cls(wrapper,
records_arr,
ts=ts_pd if attach_ts else None,
**kwargs)
@property
def ts(self) -> tp.Optional[tp.SeriesFrame]:
"""Original time series that records are built from (optional)."""
return self._ts
def to_mask(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None) -> tp.SeriesFrame:
"""Convert ranges to a mask.
See `vectorbt.generic.nb.ranges_to_mask_nb`."""
col_map = self.col_mapper.get_col_map(group_by=group_by)
mask = nb.ranges_to_mask_nb(self.get_field_arr('start_idx'),
self.get_field_arr('end_idx'),
self.get_field_arr('status'), col_map,
len(self.wrapper.index))
return self.wrapper.wrap(mask,
group_by=group_by,
**merge_dicts({}, wrap_kwargs))
@cached_property
def duration(self) -> MappedArray:
"""Duration of each range (in raw format)."""
duration = nb.range_duration_nb(self.get_field_arr('start_idx'),
self.get_field_arr('end_idx'),
self.get_field_arr('status'))
return self.map_array(duration)
@cached_method
def avg_duration(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Average range duration (as timedelta)."""
wrap_kwargs = merge_dicts(
dict(to_timedelta=True, name_or_index='avg_duration'), wrap_kwargs)
return self.duration.mean(group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def max_duration(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Maximum range duration (as timedelta)."""
wrap_kwargs = merge_dicts(
dict(to_timedelta=True, name_or_index='max_duration'), wrap_kwargs)
return self.duration.max(group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def coverage(self,
overlapping: bool = False,
normalize: bool = True,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None) -> tp.MaybeSeries:
"""Coverage, that is, the number of steps that are covered by all ranges.
See `vectorbt.generic.nb.range_coverage_nb`."""
col_map = self.col_mapper.get_col_map(group_by=group_by)
index_lens = self.wrapper.grouper.get_group_lens(
group_by=group_by) * self.wrapper.shape[0]
coverage = nb.range_coverage_nb(self.get_field_arr('start_idx'),
self.get_field_arr('end_idx'),
self.get_field_arr('status'),
col_map,
index_lens,
overlapping=overlapping,
normalize=normalize)
wrap_kwargs = merge_dicts(dict(name_or_index='coverage'), wrap_kwargs)
return self.wrapper.wrap_reduced(coverage,
group_by=group_by,
**wrap_kwargs)
# ############# Stats ############# #
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `Ranges.stats`.
Merges `vectorbt.records.base.Records.stats_defaults` and
`ranges.stats` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
ranges_stats_cfg = settings['ranges']['stats']
return merge_dicts(Records.stats_defaults.__get__(self),
ranges_stats_cfg)
_metrics: tp.ClassVar[Config] = Config(dict(
start=dict(title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'),
end=dict(title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'),
period=dict(title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper'),
coverage=dict(title='Coverage',
calc_func='coverage',
overlapping=False,
normalize=False,
apply_to_timedelta=True,
tags=['ranges', 'coverage']),
overlap_coverage=dict(title='Overlap Coverage',
calc_func='coverage',
overlapping=True,
normalize=False,
apply_to_timedelta=True,
tags=['ranges', 'coverage']),
total_records=dict(title='Total Records',
calc_func='count',
tags='records'),
duration=dict(title='Duration',
calc_func='duration.describe',
post_calc_func=lambda self, out, settings: {
'Min': out.loc['min'],
'Median': out.loc['50%'],
'Max': out.loc['max'],
'Mean': out.loc['mean'],
'Std': out.loc['std']
},
apply_to_timedelta=True,
tags=['ranges', 'duration']),
),
copy_kwargs=dict(copy_mode='deep'))
@property
def metrics(self) -> Config:
return self._metrics
# ############# Plotting ############# #
def plot(self,
column: tp.Optional[tp.Label] = None,
top_n: int = 5,
plot_zones: bool = True,
ts_trace_kwargs: tp.KwargsLike = None,
start_trace_kwargs: tp.KwargsLike = None,
end_trace_kwargs: tp.KwargsLike = None,
open_shape_kwargs: tp.KwargsLike = None,
closed_shape_kwargs: tp.KwargsLike = None,
add_trace_kwargs: tp.KwargsLike = None,
xref: str = 'x',
yref: str = 'y',
fig: tp.Optional[tp.BaseFigure] = None,
**layout_kwargs) -> tp.BaseFigure: # pragma: no cover
"""Plot ranges.
Args:
column (str): Name of the column to plot.
top_n (int): Filter top N range records by maximum duration.
plot_zones (bool): Whether to plot zones.
ts_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for `Ranges.ts`.
start_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for start values.
end_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for end values.
open_shape_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Figure.add_shape` for open zones.
closed_shape_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Figure.add_shape` for closed zones.
add_trace_kwargs (dict): Keyword arguments passed to `add_trace`.
xref (str): X coordinate axis.
yref (str): Y coordinate axis.
fig (Figure or FigureWidget): Figure to add traces to.
**layout_kwargs: Keyword arguments for layout.
## Example
```python-repl
>>> import vectorbt as vbt
>>> from datetime import datetime, timedelta
>>> import pandas as pd
>>> price = pd.Series([1, 2, 1, 2, 3, 2, 1, 2], name='Price')
>>> price.index = [datetime(2020, 1, 1) + timedelta(days=i) for i in range(len(price))]
>>> vbt.Ranges.from_ts(price >= 2, wrapper_kwargs=dict(freq='1 day')).plot()
```
"""
from vectorbt._settings import settings
plotting_cfg = settings['plotting']
self_col = self.select_one(column=column, group_by=False)
if top_n is not None:
self_col = self_col.apply_mask(self_col.duration.top_n_mask(top_n))
if ts_trace_kwargs is None:
ts_trace_kwargs = {}
ts_trace_kwargs = merge_dicts(
dict(line=dict(color=plotting_cfg['color_schema']['blue'])),
ts_trace_kwargs)
if start_trace_kwargs is None:
start_trace_kwargs = {}
if end_trace_kwargs is None:
end_trace_kwargs = {}
if open_shape_kwargs is None:
open_shape_kwargs = {}
if closed_shape_kwargs is None:
closed_shape_kwargs = {}
if add_trace_kwargs is None:
add_trace_kwargs = {}
if fig is None:
fig = make_figure()
fig.update_layout(**layout_kwargs)
y_domain = get_domain(yref, fig)
if self_col.ts is not None:
fig = self_col.ts.vbt.plot(trace_kwargs=ts_trace_kwargs,
add_trace_kwargs=add_trace_kwargs,
fig=fig)
if self_col.count() > 0:
# Extract information
id_ = self_col.get_field_arr('id')
id_title = self_col.get_field_title('id')
start_idx = self_col.get_map_field_to_index('start_idx')
start_idx_title = self_col.get_field_title('start_idx')
if self_col.ts is not None:
start_val = self_col.ts.loc[start_idx]
else:
start_val = np.full(len(start_idx), 0)
end_idx = self_col.get_map_field_to_index('end_idx')
end_idx_title = self_col.get_field_title('end_idx')
if self_col.ts is not None:
end_val = self_col.ts.loc[end_idx]
else:
end_val = np.full(len(end_idx), 0)
duration = np.vectorize(str)(self_col.wrapper.to_timedelta(
self_col.duration.values, to_pd=True, silence_warnings=True))
status = self_col.get_field_arr('status')
# Plot start markers
start_customdata = id_[:, None]
start_scatter = go.Scatter(
x=start_idx,
y=start_val,
mode='markers',
marker=dict(
symbol='diamond',
color=plotting_cfg['contrast_color_schema']['blue'],
size=7,
line=dict(
width=1,
color=adjust_lightness(
plotting_cfg['contrast_color_schema']['blue']))),
name='Start',
customdata=start_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{start_idx_title}: %{{x}}")
start_scatter.update(**start_trace_kwargs)
fig.add_trace(start_scatter, **add_trace_kwargs)
closed_mask = status == RangeStatus.Closed
if closed_mask.any():
# Plot end markers
closed_end_customdata = np.stack(
(id_[closed_mask], duration[closed_mask]), axis=1)
closed_end_scatter = go.Scatter(
x=end_idx[closed_mask],
y=end_val[closed_mask],
mode='markers',
marker=dict(
symbol='diamond',
color=plotting_cfg['contrast_color_schema']['green'],
size=7,
line=dict(width=1,
color=adjust_lightness(
plotting_cfg['contrast_color_schema']
['green']))),
name='Closed',
customdata=closed_end_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{end_idx_title}: %{{x}}"
f"<br>Duration: %{{customdata[1]}}")
closed_end_scatter.update(**end_trace_kwargs)
fig.add_trace(closed_end_scatter, **add_trace_kwargs)
if plot_zones:
# Plot closed range zones
for i in range(len(id_[closed_mask])):
fig.add_shape(**merge_dicts(
dict(
type="rect",
xref=xref,
yref="paper",
x0=start_idx[closed_mask][i],
y0=y_domain[0],
x1=end_idx[closed_mask][i],
y1=y_domain[1],
fillcolor='teal',
opacity=0.2,
layer="below",
line_width=0,
), closed_shape_kwargs))
open_mask = status == RangeStatus.Open
if open_mask.any():
# Plot end markers
open_end_customdata = np.stack(
(id_[open_mask], duration[open_mask]), axis=1)
open_end_scatter = go.Scatter(
x=end_idx[open_mask],
y=end_val[open_mask],
mode='markers',
marker=dict(
symbol='diamond',
color=plotting_cfg['contrast_color_schema']['orange'],
size=7,
line=dict(width=1,
color=adjust_lightness(
plotting_cfg['contrast_color_schema']
['orange']))),
name='Open',
customdata=open_end_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{end_idx_title}: %{{x}}"
f"<br>Duration: %{{customdata[1]}}")
open_end_scatter.update(**end_trace_kwargs)
fig.add_trace(open_end_scatter, **add_trace_kwargs)
if plot_zones:
# Plot open range zones
for i in range(len(id_[open_mask])):
fig.add_shape(**merge_dicts(
dict(
type="rect",
xref=xref,
yref="paper",
x0=start_idx[open_mask][i],
y0=y_domain[0],
x1=end_idx[open_mask][i],
y1=y_domain[1],
fillcolor='orange',
opacity=0.2,
layer="below",
line_width=0,
), open_shape_kwargs))
return fig
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `Ranges.plots`.
Merges `vectorbt.records.base.Records.plots_defaults` and
`ranges.plots` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
ranges_plots_cfg = settings['ranges']['plots']
return merge_dicts(Records.plots_defaults.__get__(self),
ranges_plots_cfg)
_subplots: tp.ClassVar[Config] = Config(
dict(plot=dict(title="Ranges",
check_is_not_grouped=True,
plot_func='plot',
tags='ranges')),
copy_kwargs=dict(copy_mode='deep'))
@property
def subplots(self) -> Config:
return self._subplots
def save(fname, names=__all__, **kwargs):
"""Save settings to a file."""
settings = dict()
for k in names:
settings[k] = getattr(this_module, k)
Config(settings).save(fname, **kwargs)
def save(fname: str, names: tp.Iterable[str] = __all__, **kwargs) -> None:
"""Save settings to a file."""
settings = dict()
for k in names:
settings[k] = getattr(this_module, k)
Config(settings).save(fname, **kwargs)
logs_field_config = Config(dict(
dtype=log_dt,
settings=dict(id=dict(title='Log Id'),
group=dict(title='Group'),
cash=dict(title='Cash'),
position=dict(title='Position'),
debt=dict(title='Debt'),
free_cash=dict(title='Free Cash'),
val_price=dict(title='Val Price'),
value=dict(title='Value'),
req_size=dict(title='Request Size'),
req_price=dict(title='Request Price'),
req_size_type=dict(title='Request Size Type',
mapping=SizeType),
req_direction=dict(title='Request Direction',
mapping=Direction),
req_fees=dict(title='Request Fees'),
req_fixed_fees=dict(title='Request Fixed Fees'),
req_slippage=dict(title='Request Slippage'),
req_min_size=dict(title='Request Min Size'),
req_max_size=dict(title='Request Max Size'),
req_size_granularity=dict(title='Request Size Granularity'),
req_reject_prob=dict(title='Request Rejection Prob'),
req_lock_cash=dict(title='Request Lock Cash'),
req_allow_partial=dict(title='Request Allow Partial'),
req_raise_reject=dict(title='Request Raise Rejection'),
req_log=dict(title='Request Log'),
new_cash=dict(title='New Cash'),
new_position=dict(title='New Position'),
new_debt=dict(title='New Debt'),
new_free_cash=dict(title='New Free Cash'),
new_val_price=dict(title='New Val Price'),
new_value=dict(title='New Value'),
res_size=dict(title='Result Size'),
res_price=dict(title='Result Price'),
res_fees=dict(title='Result Fees'),
res_side=dict(title='Result Side', mapping=OrderSide),
res_status=dict(title='Result Status', mapping=OrderStatus),
res_status_info=dict(title='Result Status Info',
mapping=OrderStatusInfo),
order_id=dict(title='Order Id'))),
readonly=True,
as_attrs=False)
import numpy as np
import plotly.graph_objects as go
from vectorbt.utils.config import Config
from vectorbt.utils.docs import fix_class_for_docs
from vectorbt.utils.widgets import CustomFigureWidget
from vectorbt.signals.enums import StopType
from vectorbt.signals.factory import SignalFactory
from vectorbt.signals.nb import (rand_enex_apply_nb, rand_by_prob_choice_nb,
stop_choice_nb, adv_stop_choice_nb)
flex_elem_param_config = Config(
array_like=
True, # passing a NumPy array means passing one value, for multiple use list
bc_to_input=True, # broadcast to input
broadcast_kwargs=dict(
keep_raw=True # keep original shape for flexible indexing to save memory
))
"""Config for flexible element-wise parameters."""
flex_col_param_config = Config(
array_like=True,
bc_to_input=1, # broadcast to axis 1 (columns)
broadcast_kwargs=dict(keep_raw=True))
"""Config for flexible column-wise parameters."""
# ############# Random signals ############# #
RAND = SignalFactory(
class_name='RAND',
for k in names:
settings[k] = getattr(this_module, k)
Config(settings).save(fname, **kwargs)
def load(fname: str, names: tp.Iterable[str] = __all__, **kwargs) -> None:
"""Load settings from a file."""
settings = Config.load(fname, **kwargs)
for k in names:
setattr(this_module, k, settings[k])
__pdoc__ = {}
# Color schema
color_schema = Config(increasing="#1b9e76", decreasing="#d95f02")
"""_"""
__pdoc__['color_schema'] = f"""Color schema.
```plaintext
{json.dumps(color_schema, indent=2, default=str)}
```
"""
# Contrast color schema
contrast_color_schema = Config(blue="#4285F4",
orange="#FFAA00",
green="#37B13F",
red="#EA4335",
gray="#E2E2E2")
Changes take effect immediately."""
import numpy as np
import json
from vectorbt.utils.config import Config
__pdoc__ = {}
# Color schema
color_schema = Config(
blue="#1f77b4",
orange="#ff7f0e",
green="#2ca02c",
red="#dc3912",
purple="#9467bd",
brown="#8c564b",
pink="#e377c2",
gray="#7f7f7f",
yellow="#bcbd22",
cyan="#17becf"
)
"""_"""
__pdoc__['color_schema'] = f"""Color schema.
```plaintext
{json.dumps(color_schema, indent=2)}
```
"""
# Contrast color schema
class Records(Wrapping, StatsBuilderMixin, PlotsBuilderMixin, RecordsWithFields, metaclass=MetaRecords):
"""Wraps the actual records array (such as trades) and exposes methods for mapping
it to some array of values (such as PnL of each trade).
Args:
wrapper (ArrayWrapper): Array wrapper.
See `vectorbt.base.array_wrapper.ArrayWrapper`.
records_arr (array_like): A structured NumPy array of records.
Must have the fields `id` (record index) and `col` (column index).
col_mapper (ColumnMapper): Column mapper if already known.
!!! note
It depends on `records_arr`, so make sure to invalidate `col_mapper` upon creating
a `Records` instance with a modified `records_arr`.
`Records.replace` does it automatically.
**kwargs: Custom keyword arguments passed to the config.
Useful if any subclass wants to extend the config.
"""
_field_config: tp.ClassVar[Config] = Config(
dict(
dtype=None,
settings=dict(
id=dict(
name='id',
title='Id'
),
col=dict(
name='col',
title='Column',
mapping='columns'
),
idx=dict(
name='idx',
title='Timestamp',
mapping='index'
)
)
),
readonly=True,
as_attrs=False
)
@property
def field_config(self) -> Config:
"""Field config of `${cls_name}`.
```json
${field_config}
```
"""
return self._field_config
def __init__(self,
wrapper: ArrayWrapper,
records_arr: tp.RecordArray,
col_mapper: tp.Optional[ColumnMapper] = None,
**kwargs) -> None:
Wrapping.__init__(
self,
wrapper,
records_arr=records_arr,
col_mapper=col_mapper,
**kwargs
)
StatsBuilderMixin.__init__(self)
# Check fields
records_arr = np.asarray(records_arr)
checks.assert_not_none(records_arr.dtype.fields)
field_names = {
dct.get('name', field_name)
for field_name, dct in self.field_config.get('settings', {}).items()
}
dtype = self.field_config.get('dtype', None)
if dtype is not None:
for field in dtype.names:
if field not in records_arr.dtype.names:
if field not in field_names:
raise TypeError(f"Field '{field}' from {dtype} cannot be found in records or config")
self._records_arr = records_arr
if col_mapper is None:
col_mapper = ColumnMapper(wrapper, self.col_arr)
self._col_mapper = col_mapper
def replace(self: RecordsT, **kwargs) -> RecordsT:
"""See `vectorbt.utils.config.Configured.replace`.
Also, makes sure that `Records.col_mapper` is not passed to the new instance."""
if self.config.get('col_mapper', None) is not None:
if 'wrapper' in kwargs:
if self.wrapper is not kwargs.get('wrapper'):
kwargs['col_mapper'] = None
if 'records_arr' in kwargs:
if self.records_arr is not kwargs.get('records_arr'):
kwargs['col_mapper'] = None
return Configured.replace(self, **kwargs)
def get_by_col_idxs(self, col_idxs: tp.Array1d) -> tp.RecordArray:
"""Get records corresponding to column indices.
Returns new records array."""
if self.col_mapper.is_sorted():
new_records_arr = nb.record_col_range_select_nb(
self.values, self.col_mapper.col_range, to_1d_array(col_idxs)) # faster
else:
new_records_arr = nb.record_col_map_select_nb(
self.values, self.col_mapper.col_map, to_1d_array(col_idxs))
return new_records_arr
def indexing_func_meta(self, pd_indexing_func: tp.PandasIndexingFunc, **kwargs) -> IndexingMetaT:
"""Perform indexing on `Records` and return metadata."""
new_wrapper, _, group_idxs, col_idxs = \
self.wrapper.indexing_func_meta(pd_indexing_func, column_only_select=True, **kwargs)
new_records_arr = self.get_by_col_idxs(col_idxs)
return new_wrapper, new_records_arr, group_idxs, col_idxs
def indexing_func(self: RecordsT, pd_indexing_func: tp.PandasIndexingFunc, **kwargs) -> RecordsT:
"""Perform indexing on `Records`."""
new_wrapper, new_records_arr, _, _ = self.indexing_func_meta(pd_indexing_func, **kwargs)
return self.replace(
wrapper=new_wrapper,
records_arr=new_records_arr
)
@property
def records_arr(self) -> tp.RecordArray:
"""Records array."""
return self._records_arr
@property
def values(self) -> tp.RecordArray:
"""Records array."""
return self.records_arr
def __len__(self) -> int:
return len(self.values)
@property
def records(self) -> tp.Frame:
"""Records."""
return pd.DataFrame.from_records(self.values)
@property
def recarray(self) -> tp.RecArray:
return self.values.view(np.recarray)
@property
def col_mapper(self) -> ColumnMapper:
"""Column mapper.
See `vectorbt.records.col_mapper.ColumnMapper`."""
return self._col_mapper
@property
def records_readable(self) -> tp.Frame:
"""Records in readable format."""
df = self.records.copy()
field_settings = self.field_config.get('settings', {})
for col_name in df.columns:
if col_name in field_settings:
dct = field_settings[col_name]
if dct.get('ignore', False):
df = df.drop(columns=col_name)
continue
field_name = dct.get('name', col_name)
if 'title' in dct:
title = dct['title']
new_columns = dict()
new_columns[field_name] = title
df.rename(columns=new_columns, inplace=True)
else:
title = field_name
if 'mapping' in dct:
if isinstance(dct['mapping'], str) and dct['mapping'] == 'index':
df[title] = self.get_map_field_to_index(col_name)
else:
df[title] = self.get_apply_mapping_arr(col_name)
return df
def get_field_setting(self, field: str, setting: str, default: tp.Any = None) -> tp.Any:
"""Resolve any setting of the field. Uses `Records.field_config`."""
return self.field_config.get('settings', {}).get(field, {}).get(setting, default)
def get_field_name(self, field: str) -> str:
"""Resolve the name of the field. Uses `Records.field_config`.."""
return self.get_field_setting(field, 'name', field)
def get_field_title(self, field: str) -> str:
"""Resolve the title of the field. Uses `Records.field_config`."""
return self.get_field_setting(field, 'title', field)
def get_field_mapping(self, field: str) -> tp.Optional[tp.MappingLike]:
"""Resolve the mapping of the field. Uses `Records.field_config`."""
return self.get_field_setting(field, 'mapping', None)
def get_field_arr(self, field: str) -> tp.Array1d:
"""Resolve the array of the field. Uses `Records.field_config`."""
return self.values[self.get_field_name(field)]
def get_map_field(self, field: str, **kwargs) -> MappedArray:
"""Resolve the mapped array of the field. Uses `Records.field_config`."""
return self.map_field(self.get_field_name(field), mapping=self.get_field_mapping(field), **kwargs)
def get_apply_mapping_arr(self, field: str, **kwargs) -> tp.Array1d:
"""Resolve the mapped array on the field, with mapping applied. Uses `Records.field_config`."""
return self.get_map_field(field, **kwargs).apply_mapping().values
def get_map_field_to_index(self, field: str, **kwargs) -> tp.Index:
"""Resolve the mapped array on the field, with index applied. Uses `Records.field_config`."""
return self.get_map_field(field, **kwargs).to_index()
@property
def id_arr(self) -> tp.Array1d:
"""Get id array."""
return self.values[self.get_field_name('id')]
@property
def col_arr(self) -> tp.Array1d:
"""Get column array."""
return self.values[self.get_field_name('col')]
@property
def idx_arr(self) -> tp.Optional[tp.Array1d]:
"""Get index array."""
idx_field_name = self.get_field_name('idx')
if idx_field_name is None:
return None
return self.values[idx_field_name]
@cached_method
def is_sorted(self, incl_id: bool = False) -> bool:
"""Check whether records are sorted."""
if incl_id:
return nb.is_col_idx_sorted_nb(self.col_arr, self.id_arr)
return nb.is_col_sorted_nb(self.col_arr)
def sort(self: RecordsT, incl_id: bool = False, group_by: tp.GroupByLike = None, **kwargs) -> RecordsT:
"""Sort records by columns (primary) and ids (secondary, optional).
!!! note
Sorting is expensive. A better approach is to append records already in the correct order."""
if self.is_sorted(incl_id=incl_id):
return self.replace(**kwargs).regroup(group_by)
if incl_id:
ind = np.lexsort((self.id_arr, self.col_arr)) # expensive!
else:
ind = np.argsort(self.col_arr)
return self.replace(records_arr=self.values[ind], **kwargs).regroup(group_by)
def apply_mask(self: RecordsT, mask: tp.Array1d, group_by: tp.GroupByLike = None, **kwargs) -> RecordsT:
"""Return a new class instance, filtered by mask."""
mask_indices = np.flatnonzero(mask)
return self.replace(
records_arr=np.take(self.values, mask_indices),
**kwargs
).regroup(group_by)
def map_array(self,
a: tp.ArrayLike,
idx_arr: tp.Optional[tp.ArrayLike] = None,
mapping: tp.Optional[tp.MappingLike] = None,
group_by: tp.GroupByLike = None,
**kwargs) -> MappedArray:
"""Convert array to mapped array.
The length of the array should match that of the records."""
if not isinstance(a, np.ndarray):
a = np.asarray(a)
checks.assert_shape_equal(a, self.values)
if idx_arr is None:
idx_arr = self.idx_arr
return MappedArray(
self.wrapper,
a,
self.col_arr,
id_arr=self.id_arr,
idx_arr=idx_arr,
mapping=mapping,
col_mapper=self.col_mapper,
**kwargs
).regroup(group_by)
def map_field(self, field: str, **kwargs) -> MappedArray:
"""Convert field to mapped array.
`**kwargs` are passed to `Records.map_array`."""
mapped_arr = self.values[field]
return self.map_array(mapped_arr, **kwargs)
def map(self,
map_func_nb: tp.RecordMapFunc, *args,
dtype: tp.Optional[tp.DTypeLike] = None,
**kwargs) -> MappedArray:
"""Map each record to a scalar value. Returns mapped array.
See `vectorbt.records.nb.map_records_nb`.
`**kwargs` are passed to `Records.map_array`."""
checks.assert_numba_func(map_func_nb)
mapped_arr = nb.map_records_nb(self.values, map_func_nb, *args)
mapped_arr = np.asarray(mapped_arr, dtype=dtype)
return self.map_array(mapped_arr, **kwargs)
def apply(self,
apply_func_nb: tp.RecordApplyFunc, *args,
group_by: tp.GroupByLike = None,
apply_per_group: bool = False,
dtype: tp.Optional[tp.DTypeLike] = None,
**kwargs) -> MappedArray:
"""Apply function on records per column/group. Returns mapped array.
Applies per group if `apply_per_group` is True.
See `vectorbt.records.nb.apply_on_records_nb`.
`**kwargs` are passed to `Records.map_array`."""
checks.assert_numba_func(apply_func_nb)
if apply_per_group:
col_map = self.col_mapper.get_col_map(group_by=group_by)
else:
col_map = self.col_mapper.get_col_map(group_by=False)
mapped_arr = nb.apply_on_records_nb(self.values, col_map, apply_func_nb, *args)
mapped_arr = np.asarray(mapped_arr, dtype=dtype)
return self.map_array(mapped_arr, group_by=group_by, **kwargs)
@cached_method
def count(self, group_by: tp.GroupByLike = None, wrap_kwargs: tp.KwargsLike = None) -> tp.MaybeSeries:
"""Return count by column."""
wrap_kwargs = merge_dicts(dict(name_or_index='count'), wrap_kwargs)
return self.wrapper.wrap_reduced(
self.col_mapper.get_col_map(group_by=group_by)[1],
group_by=group_by, **wrap_kwargs)
# ############# Stats ############# #
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `Records.stats`.
Merges `vectorbt.generic.stats_builder.StatsBuilderMixin.stats_defaults` and
`records.stats` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
records_stats_cfg = settings['records']['stats']
return merge_dicts(
StatsBuilderMixin.stats_defaults.__get__(self),
records_stats_cfg
)
_metrics: tp.ClassVar[Config] = Config(
dict(
start=dict(
title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'
),
end=dict(
title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'
),
period=dict(
title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper'
),
count=dict(
title='Count',
calc_func='count',
tags='records'
)
),
copy_kwargs=dict(copy_mode='deep')
)
@property
def metrics(self) -> Config:
return self._metrics
# ############# Plotting ############# #
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `Records.plots`.
Merges `vectorbt.generic.plots_builder.PlotsBuilderMixin.plots_defaults` and
`records.plots` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
records_plots_cfg = settings['records']['plots']
return merge_dicts(
PlotsBuilderMixin.plots_defaults.__get__(self),
records_plots_cfg
)
@property
def subplots(self) -> Config:
return self._subplots
# ############# Docs ############# #
@classmethod
def build_field_config_doc(cls, source_cls: tp.Optional[type] = None) -> str:
"""Build field config documentation."""
if source_cls is None:
source_cls = Records
return string.Template(
inspect.cleandoc(get_dict_attr(source_cls, 'field_config').__doc__)
).substitute(
{'field_config': cls.field_config.to_doc(), 'cls_name': cls.__name__}
)
@classmethod
def override_field_config_doc(cls, __pdoc__: dict, source_cls: tp.Optional[type] = None) -> None:
"""Call this method on each subclass that overrides `field_config`."""
__pdoc__[cls.__name__ + '.field_config'] = cls.build_field_config_doc(source_cls=source_cls)
class OHLCVDFAccessor(GenericDFAccessor): # pragma: no cover
"""Accessor on top of OHLCV data. For DataFrames only.
Accessible through `pd.DataFrame.vbt.ohlcv`."""
def __init__(self, obj: tp.Frame, column_names: tp.KwargsLike = None, **kwargs) -> None:
self._column_names = column_names
GenericDFAccessor.__init__(self, obj, column_names=column_names, **kwargs)
@property
def column_names(self) -> tp.Kwargs:
"""Column names."""
from vectorbt._settings import settings
ohlcv_cfg = settings['ohlcv']
return merge_dicts(ohlcv_cfg['column_names'], self._column_names)
def get_column(self, col_name: str) -> tp.Optional[tp.Series]:
"""Get column from `OHLCVDFAccessor.column_names`."""
df_column_names = self.obj.columns.str.lower().tolist()
col_name = self.column_names[col_name].lower()
if col_name not in df_column_names:
return None
return self.obj.iloc[:, df_column_names.index(col_name)]
@property
def open(self) -> tp.Optional[tp.Series]:
"""Open series."""
return self.get_column('open')
@property
def high(self) -> tp.Optional[tp.Series]:
"""High series."""
return self.get_column('high')
@property
def low(self) -> tp.Optional[tp.Series]:
"""Low series."""
return self.get_column('low')
@property
def close(self) -> tp.Optional[tp.Series]:
"""Close series."""
return self.get_column('close')
@property
def ohlc(self) -> tp.Optional[tp.Frame]:
"""Open, high, low, and close series."""
to_concat = []
if self.open is not None:
to_concat.append(self.open)
if self.high is not None:
to_concat.append(self.high)
if self.low is not None:
to_concat.append(self.low)
if self.close is not None:
to_concat.append(self.close)
if len(to_concat) == 0:
return None
return pd.concat(to_concat, axis=1)
@property
def volume(self) -> tp.Optional[tp.Series]:
"""Volume series."""
return self.get_column('volume')
# ############# Stats ############# #
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `OHLCVDFAccessor.stats`.
Merges `vectorbt.generic.accessors.GenericAccessor.stats_defaults` and
`ohlcv.stats` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
ohlcv_stats_cfg = settings['ohlcv']['stats']
return merge_dicts(
GenericAccessor.stats_defaults.__get__(self),
ohlcv_stats_cfg
)
_metrics: tp.ClassVar[Config] = Config(
dict(
start=dict(
title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'
),
end=dict(
title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'
),
period=dict(
title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper'
),
first_price=dict(
title='First Price',
calc_func=lambda ohlc: nb.bfill_1d_nb(ohlc.values.flatten())[0],
resolve_ohlc=True,
tags=['ohlcv', 'ohlc']
),
lowest_price=dict(
title='Lowest Price',
calc_func=lambda ohlc: ohlc.values.min(),
resolve_ohlc=True,
tags=['ohlcv', 'ohlc']
),
highest_price=dict(
title='Highest Price',
calc_func=lambda ohlc: ohlc.values.max(),
resolve_ohlc=True,
tags=['ohlcv', 'ohlc']
),
last_price=dict(
title='Last Price',
calc_func=lambda ohlc: nb.ffill_1d_nb(ohlc.values.flatten())[-1],
resolve_ohlc=True,
tags=['ohlcv', 'ohlc']
),
first_volume=dict(
title='First Volume',
calc_func=lambda volume: nb.bfill_1d_nb(volume.values)[0],
resolve_volume=True,
tags=['ohlcv', 'volume']
),
lowest_volume=dict(
title='Lowest Volume',
calc_func=lambda volume: volume.values.min(),
resolve_volume=True,
tags=['ohlcv', 'volume']
),
highest_volume=dict(
title='Highest Volume',
calc_func=lambda volume: volume.values.max(),
resolve_volume=True,
tags=['ohlcv', 'volume']
),
last_volume=dict(
title='Last Volume',
calc_func=lambda volume: nb.ffill_1d_nb(volume.values)[-1],
resolve_volume=True,
tags=['ohlcv', 'volume']
),
),
copy_kwargs=dict(copy_mode='deep')
)
@property
def metrics(self) -> Config:
return self._metrics
# ############# Plotting ############# #
def plot(self,
plot_type: tp.Union[None, str, tp.BaseTraceType] = None,
show_volume: tp.Optional[bool] = None,
ohlc_kwargs: tp.KwargsLike = None,
volume_kwargs: tp.KwargsLike = None,
ohlc_add_trace_kwargs: tp.KwargsLike = None,
volume_add_trace_kwargs: tp.KwargsLike = None,
fig: tp.Optional[tp.BaseFigure] = None,
**layout_kwargs) -> tp.BaseFigure: # pragma: no cover
"""Plot OHLCV data.
Args:
plot_type: Either 'OHLC', 'Candlestick' or Plotly trace.
Pass None to use the default.
show_volume (bool): If True, shows volume as bar chart.
ohlc_kwargs (dict): Keyword arguments passed to `plot_type`.
volume_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Bar`.
ohlc_add_trace_kwargs (dict): Keyword arguments passed to `add_trace` for OHLC.
volume_add_trace_kwargs (dict): Keyword arguments passed to `add_trace` for volume.
fig (Figure or FigureWidget): Figure to add traces to.
**layout_kwargs: Keyword arguments for layout.
## Example
```python-repl
>>> import vectorbt as vbt
>>> vbt.YFData.download("BTC-USD").get().vbt.ohlcv.plot()
```
"""
from vectorbt._settings import settings
plotting_cfg = settings['plotting']
ohlcv_cfg = settings['ohlcv']
if ohlc_kwargs is None:
ohlc_kwargs = {}
if volume_kwargs is None:
volume_kwargs = {}
if ohlc_add_trace_kwargs is None:
ohlc_add_trace_kwargs = {}
if volume_add_trace_kwargs is None:
volume_add_trace_kwargs = {}
if show_volume is None:
show_volume = self.volume is not None
if show_volume:
ohlc_add_trace_kwargs = merge_dicts(dict(row=1, col=1), ohlc_add_trace_kwargs)
volume_add_trace_kwargs = merge_dicts(dict(row=2, col=1), volume_add_trace_kwargs)
# Set up figure
if fig is None:
if show_volume:
fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0, row_heights=[0.7, 0.3])
else:
fig = make_figure()
fig.update_layout(
showlegend=True,
xaxis=dict(
rangeslider_visible=False,
showgrid=True
),
yaxis=dict(
showgrid=True
)
)
if show_volume:
fig.update_layout(
xaxis2=dict(
showgrid=True
),
yaxis2=dict(
showgrid=True
),
bargap=0
)
fig.update_layout(**layout_kwargs)
if plot_type is None:
plot_type = ohlcv_cfg['plot_type']
if isinstance(plot_type, str):
if plot_type.lower() == 'ohlc':
plot_type = 'OHLC'
plot_obj = go.Ohlc
elif plot_type.lower() == 'candlestick':
plot_type = 'Candlestick'
plot_obj = go.Candlestick
else:
raise ValueError("Plot type can be either 'OHLC' or 'Candlestick'")
else:
plot_obj = plot_type
ohlc = plot_obj(
x=self.wrapper.index,
open=self.open,
high=self.high,
low=self.low,
close=self.close,
name=plot_type,
increasing=dict(
line=dict(
color=plotting_cfg['color_schema']['increasing']
)
),
decreasing=dict(
line=dict(
color=plotting_cfg['color_schema']['decreasing']
)
)
)
ohlc.update(**ohlc_kwargs)
fig.add_trace(ohlc, **ohlc_add_trace_kwargs)
if show_volume:
marker_colors = np.empty(self.volume.shape, dtype=object)
marker_colors[(self.close.values - self.open.values) > 0] = plotting_cfg['color_schema']['increasing']
marker_colors[(self.close.values - self.open.values) == 0] = plotting_cfg['color_schema']['gray']
marker_colors[(self.close.values - self.open.values) < 0] = plotting_cfg['color_schema']['decreasing']
volume_bar = go.Bar(
x=self.wrapper.index,
y=self.volume,
marker=dict(
color=marker_colors,
line_width=0
),
opacity=0.5,
name='Volume'
)
volume_bar.update(**volume_kwargs)
fig.add_trace(volume_bar, **volume_add_trace_kwargs)
return fig
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `OHLCVDFAccessor.plots`.
Merges `vectorbt.generic.accessors.GenericAccessor.plots_defaults` and
`ohlcv.plots` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
ohlcv_plots_cfg = settings['ohlcv']['plots']
return merge_dicts(
GenericAccessor.plots_defaults.__get__(self),
ohlcv_plots_cfg
)
_subplots: tp.ClassVar[Config] = Config(
dict(
plot=dict(
title='OHLC',
xaxis_kwargs=dict(
showgrid=True,
rangeslider_visible=False
),
yaxis_kwargs=dict(
showgrid=True
),
check_is_not_grouped=True,
plot_func='plot',
show_volume=False,
tags='ohlcv'
)
),
copy_kwargs=dict(copy_mode='deep')
)
@property
def subplots(self) -> Config:
return self._subplots
self.register_template(theme)
self['plotting']['color_schema'].update(self['plotting']['themes'][theme]['color_schema'])
self['plotting']['layout']['template'] = 'vbt_' + theme
def reset_theme(self) -> None:
"""Reset to default theme."""
self.set_theme('light')
settings = SettingsConfig(
dict(
numba=dict(
check_func_type=True,
check_func_suffix=False
),
config=Config(), # flex
configured=dict(
config=Config( # flex
dict(
readonly=True
)
),
),
caching=dict(
enabled=True,
whitelist=[
CacheCondition(base_cls=ArrayWrapper),
CacheCondition(base_cls=ColumnGrouper),
CacheCondition(base_cls=ColumnMapper)
],
blacklist=[]
class Logs(Records):
"""Extends `Records` for working with log records."""
@property
def field_config(self) -> Config:
return self._field_config
# ############# Stats ############# #
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `Logs.stats`.
Merges `vectorbt.records.base.Records.stats_defaults` and
`logs.stats` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
logs_stats_cfg = settings['logs']['stats']
return merge_dicts(Records.stats_defaults.__get__(self),
logs_stats_cfg)
_metrics: tp.ClassVar[Config] = Config(dict(
start=dict(title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'),
end=dict(title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'),
period=dict(title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper'),
total_records=dict(title='Total Records',
calc_func='count',
tags='records'),
res_status_counts=dict(title='Status Counts',
calc_func='res_status.value_counts',
incl_all_keys=True,
post_calc_func=lambda self, out, settings:
to_dict(out, orient='index_series'),
tags=['logs', 'res_status', 'value_counts']),
res_status_info_counts=dict(
title='Status Info Counts',
calc_func='res_status_info.value_counts',
post_calc_func=lambda self, out, settings: to_dict(
out, orient='index_series'),
tags=['logs', 'res_status_info', 'value_counts'])),
copy_kwargs=dict(copy_mode='deep'))
@property
def metrics(self) -> Config:
return self._metrics
# ############# Plotting ############# #
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `Logs.plots`.
Merges `vectorbt.records.base.Records.plots_defaults` and
`logs.plots` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
logs_plots_cfg = settings['logs']['plots']
return merge_dicts(Records.plots_defaults.__get__(self),
logs_plots_cfg)
@property
def subplots(self) -> Config:
return self._subplots
from vectorbt.records.base import Records
from vectorbt.records.decorators import override_field_config, attach_fields
from vectorbt.records.mapped_array import MappedArray
from vectorbt.utils.colors import adjust_lightness
from vectorbt.utils.config import merge_dicts, Config
from vectorbt.utils.decorators import cached_property, cached_method
from vectorbt.utils.figure import make_figure, get_domain
__pdoc__ = {}
ranges_field_config = Config(
dict(
dtype=range_dt,
settings=dict(
id=dict(title='Range Id'),
idx=dict(name='end_idx' # remap field of Records
),
start_idx=dict(title='Start Timestamp', mapping='index'),
end_idx=dict(title='End Timestamp', mapping='index'),
status=dict(title='Status', mapping=RangeStatus))),
readonly=True,
as_attrs=False)
"""_"""
__pdoc__['ranges_field_config'] = f"""Field config for `Ranges`.
```json
{ranges_field_config.to_doc()}
```
"""
ranges_attach_field_config = Config(dict(status=dict(attach_filters=True)),
class MappedArray(Wrapping,
StatsBuilderMixin,
PlotsBuilderMixin,
metaclass=MetaMappedArray):
"""Exposes methods for reducing, converting, and plotting arrays mapped by
`vectorbt.records.base.Records` class.
Args:
wrapper (ArrayWrapper): Array wrapper.
See `vectorbt.base.array_wrapper.ArrayWrapper`.
mapped_arr (array_like): A one-dimensional array of mapped record values.
col_arr (array_like): A one-dimensional column array.
Must be of the same size as `mapped_arr`.
id_arr (array_like): A one-dimensional id array. Defaults to simple range.
Must be of the same size as `mapped_arr`.
idx_arr (array_like): A one-dimensional index array. Optional.
Must be of the same size as `mapped_arr`.
mapping (namedtuple, dict or callable): Mapping.
col_mapper (ColumnMapper): Column mapper if already known.
!!! note
It depends upon `wrapper` and `col_arr`, so make sure to invalidate `col_mapper` upon creating
a `MappedArray` instance with a modified `wrapper` or `col_arr.
`MappedArray.replace` does it automatically.
**kwargs: Custom keyword arguments passed to the config.
Useful if any subclass wants to extend the config.
"""
def __init__(self,
wrapper: ArrayWrapper,
mapped_arr: tp.ArrayLike,
col_arr: tp.ArrayLike,
id_arr: tp.Optional[tp.ArrayLike] = None,
idx_arr: tp.Optional[tp.ArrayLike] = None,
mapping: tp.Optional[tp.MappingLike] = None,
col_mapper: tp.Optional[ColumnMapper] = None,
**kwargs) -> None:
Wrapping.__init__(self,
wrapper,
mapped_arr=mapped_arr,
col_arr=col_arr,
id_arr=id_arr,
idx_arr=idx_arr,
mapping=mapping,
col_mapper=col_mapper,
**kwargs)
StatsBuilderMixin.__init__(self)
mapped_arr = np.asarray(mapped_arr)
col_arr = np.asarray(col_arr)
checks.assert_shape_equal(mapped_arr, col_arr, axis=0)
if id_arr is None:
id_arr = np.arange(len(mapped_arr))
else:
id_arr = np.asarray(id_arr)
if idx_arr is not None:
idx_arr = np.asarray(idx_arr)
checks.assert_shape_equal(mapped_arr, idx_arr, axis=0)
if mapping is not None:
if isinstance(mapping, str):
if mapping.lower() == 'index':
mapping = self.wrapper.index
elif mapping.lower() == 'columns':
mapping = self.wrapper.columns
mapping = to_mapping(mapping)
self._mapped_arr = mapped_arr
self._id_arr = id_arr
self._col_arr = col_arr
self._idx_arr = idx_arr
self._mapping = mapping
if col_mapper is None:
col_mapper = ColumnMapper(wrapper, col_arr)
self._col_mapper = col_mapper
def replace(self: MappedArrayT, **kwargs) -> MappedArrayT:
"""See `vectorbt.utils.config.Configured.replace`.
Also, makes sure that `MappedArray.col_mapper` is not passed to the new instance."""
if self.config.get('col_mapper', None) is not None:
if 'wrapper' in kwargs:
if self.wrapper is not kwargs.get('wrapper'):
kwargs['col_mapper'] = None
if 'col_arr' in kwargs:
if self.col_arr is not kwargs.get('col_arr'):
kwargs['col_mapper'] = None
return Configured.replace(self, **kwargs)
def indexing_func_meta(self, pd_indexing_func: tp.PandasIndexingFunc,
**kwargs) -> IndexingMetaT:
"""Perform indexing on `MappedArray` and return metadata."""
new_wrapper, _, group_idxs, col_idxs = \
self.wrapper.indexing_func_meta(pd_indexing_func, column_only_select=True, **kwargs)
new_indices, new_col_arr = self.col_mapper._col_idxs_meta(col_idxs)
new_mapped_arr = self.values[new_indices]
new_id_arr = self.id_arr[new_indices]
if self.idx_arr is not None:
new_idx_arr = self.idx_arr[new_indices]
else:
new_idx_arr = None
return new_wrapper, new_mapped_arr, new_col_arr, new_id_arr, new_idx_arr, group_idxs, col_idxs
def indexing_func(self: MappedArrayT,
pd_indexing_func: tp.PandasIndexingFunc,
**kwargs) -> MappedArrayT:
"""Perform indexing on `MappedArray`."""
new_wrapper, new_mapped_arr, new_col_arr, new_id_arr, new_idx_arr, _, _ = \
self.indexing_func_meta(pd_indexing_func, **kwargs)
return self.replace(wrapper=new_wrapper,
mapped_arr=new_mapped_arr,
col_arr=new_col_arr,
id_arr=new_id_arr,
idx_arr=new_idx_arr)
@property
def mapped_arr(self) -> tp.Array1d:
"""Mapped array."""
return self._mapped_arr
@property
def values(self) -> tp.Array1d:
"""Mapped array."""
return self.mapped_arr
def __len__(self) -> int:
return len(self.values)
@property
def col_arr(self) -> tp.Array1d:
"""Column array."""
return self._col_arr
@property
def col_mapper(self) -> ColumnMapper:
"""Column mapper.
See `vectorbt.records.col_mapper.ColumnMapper`."""
return self._col_mapper
@property
def id_arr(self) -> tp.Array1d:
"""Id array."""
return self._id_arr
@property
def idx_arr(self) -> tp.Optional[tp.Array1d]:
"""Index array."""
return self._idx_arr
@property
def mapping(self) -> tp.Optional[tp.Mapping]:
"""Mapping."""
return self._mapping
@cached_method
def is_sorted(self, incl_id: bool = False) -> bool:
"""Check whether mapped array is sorted."""
if incl_id:
return nb.is_col_idx_sorted_nb(self.col_arr, self.id_arr)
return nb.is_col_sorted_nb(self.col_arr)
def sort(self: MappedArrayT,
incl_id: bool = False,
idx_arr: tp.Optional[tp.Array1d] = None,
group_by: tp.GroupByLike = None,
**kwargs) -> MappedArrayT:
"""Sort mapped array by column array (primary) and id array (secondary, optional).
`**kwargs` are passed to `MappedArray.replace`."""
if idx_arr is None:
idx_arr = self.idx_arr
if self.is_sorted(incl_id=incl_id):
return self.replace(idx_arr=idx_arr, **kwargs).regroup(group_by)
if incl_id:
ind = np.lexsort((self.id_arr, self.col_arr)) # expensive!
else:
ind = np.argsort(self.col_arr)
return self.replace(
mapped_arr=self.values[ind],
col_arr=self.col_arr[ind],
id_arr=self.id_arr[ind],
idx_arr=idx_arr[ind] if idx_arr is not None else None,
**kwargs).regroup(group_by)
def apply_mask(self: MappedArrayT,
mask: tp.Array1d,
idx_arr: tp.Optional[tp.Array1d] = None,
group_by: tp.GroupByLike = None,
**kwargs) -> MappedArrayT:
"""Return a new class instance, filtered by mask.
`**kwargs` are passed to `MappedArray.replace`."""
if idx_arr is None:
idx_arr = self.idx_arr
mask_indices = np.flatnonzero(mask)
return self.replace(mapped_arr=np.take(self.values, mask_indices),
col_arr=np.take(self.col_arr, mask_indices),
id_arr=np.take(self.id_arr, mask_indices),
idx_arr=np.take(idx_arr, mask_indices)
if idx_arr is not None else None,
**kwargs).regroup(group_by)
def map_to_mask(self,
inout_map_func_nb: tp.MaskInOutMapFunc,
*args,
group_by: tp.GroupByLike = None) -> tp.Array1d:
"""Map mapped array to a mask.
See `vectorbt.records.nb.mapped_to_mask_nb`."""
col_map = self.col_mapper.get_col_map(group_by=group_by)
return nb.mapped_to_mask_nb(self.values, col_map, inout_map_func_nb,
*args)
@cached_method
def top_n_mask(self, n: int, **kwargs) -> tp.Array1d:
"""Return mask of top N elements in each column/group."""
return self.map_to_mask(nb.top_n_inout_map_nb, n, **kwargs)
@cached_method
def bottom_n_mask(self, n: int, **kwargs) -> tp.Array1d:
"""Return mask of bottom N elements in each column/group."""
return self.map_to_mask(nb.bottom_n_inout_map_nb, n, **kwargs)
@cached_method
def top_n(self: MappedArrayT, n: int, **kwargs) -> MappedArrayT:
"""Filter top N elements from each column/group."""
return self.apply_mask(self.top_n_mask(n), **kwargs)
@cached_method
def bottom_n(self: MappedArrayT, n: int, **kwargs) -> MappedArrayT:
"""Filter bottom N elements from each column/group."""
return self.apply_mask(self.bottom_n_mask(n), **kwargs)
@cached_method
def is_expandable(self,
idx_arr: tp.Optional[tp.Array1d] = None,
group_by: tp.GroupByLike = None) -> bool:
"""See `vectorbt.records.nb.is_mapped_expandable_nb`."""
if idx_arr is None:
if self.idx_arr is None:
raise ValueError("Must pass idx_arr")
idx_arr = self.idx_arr
col_arr = self.col_mapper.get_col_arr(group_by=group_by)
target_shape = self.wrapper.get_shape_2d(group_by=group_by)
return nb.is_mapped_expandable_nb(col_arr, idx_arr, target_shape)
def to_pd(self,
idx_arr: tp.Optional[tp.Array1d] = None,
ignore_index: bool = False,
fill_value: float = np.nan,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None) -> tp.SeriesFrame:
"""Expand mapped array to a Series/DataFrame.
If `ignore_index`, will ignore the index and stack data points on top of each other in every column/group
(see `vectorbt.records.nb.stack_expand_mapped_nb`). Otherwise, see `vectorbt.records.nb.expand_mapped_nb`.
!!! note
Will raise an error if there are multiple values pointing to the same position.
Set `ignore_index` to True in this case.
!!! warning
Mapped arrays represent information in the most memory-friendly format.
Mapping back to pandas may occupy lots of memory if records are sparse."""
if ignore_index:
if self.wrapper.ndim == 1:
return self.wrapper.wrap(self.values,
index=np.arange(len(self.values)),
group_by=group_by,
**merge_dicts({}, wrap_kwargs))
col_map = self.col_mapper.get_col_map(group_by=group_by)
out = nb.stack_expand_mapped_nb(self.values, col_map, fill_value)
return self.wrapper.wrap(out,
index=np.arange(out.shape[0]),
group_by=group_by,
**merge_dicts({}, wrap_kwargs))
if idx_arr is None:
if self.idx_arr is None:
raise ValueError("Must pass idx_arr")
idx_arr = self.idx_arr
if not self.is_expandable(idx_arr=idx_arr, group_by=group_by):
raise ValueError(
"Multiple values are pointing to the same position. Use ignore_index."
)
col_arr = self.col_mapper.get_col_arr(group_by=group_by)
target_shape = self.wrapper.get_shape_2d(group_by=group_by)
out = nb.expand_mapped_nb(self.values, col_arr, idx_arr, target_shape,
fill_value)
return self.wrapper.wrap(out,
group_by=group_by,
**merge_dicts({}, wrap_kwargs))
def apply(self: MappedArrayT,
apply_func_nb: tp.MappedApplyFunc,
*args,
group_by: tp.GroupByLike = None,
apply_per_group: bool = False,
dtype: tp.Optional[tp.DTypeLike] = None,
**kwargs) -> MappedArrayT:
"""Apply function on mapped array per column/group. Returns mapped array.
Applies per group if `apply_per_group` is True.
See `vectorbt.records.nb.apply_on_mapped_nb`.
`**kwargs` are passed to `MappedArray.replace`."""
checks.assert_numba_func(apply_func_nb)
if apply_per_group:
col_map = self.col_mapper.get_col_map(group_by=group_by)
else:
col_map = self.col_mapper.get_col_map(group_by=False)
mapped_arr = nb.apply_on_mapped_nb(self.values, col_map, apply_func_nb,
*args)
mapped_arr = np.asarray(mapped_arr, dtype=dtype)
return self.replace(mapped_arr=mapped_arr, **kwargs).regroup(group_by)
def reduce(self,
reduce_func_nb: tp.ReduceFunc,
*args,
idx_arr: tp.Optional[tp.Array1d] = None,
returns_array: bool = False,
returns_idx: bool = False,
to_index: bool = True,
fill_value: tp.Scalar = np.nan,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None) -> tp.MaybeSeriesFrame:
"""Reduce mapped array by column/group.
If `returns_array` is False and `returns_idx` is False, see `vectorbt.records.nb.reduce_mapped_nb`.
If `returns_array` is False and `returns_idx` is True, see `vectorbt.records.nb.reduce_mapped_to_idx_nb`.
If `returns_array` is True and `returns_idx` is False, see `vectorbt.records.nb.reduce_mapped_to_array_nb`.
If `returns_array` is True and `returns_idx` is True, see `vectorbt.records.nb.reduce_mapped_to_idx_array_nb`.
If `returns_idx` is True, must pass `idx_arr`. Set `to_index` to False to return raw positions instead
of labels. Use `fill_value` to set the default value. Set `group_by` to False to disable grouping.
"""
# Perform checks
checks.assert_numba_func(reduce_func_nb)
if idx_arr is None:
if self.idx_arr is None:
if returns_idx:
raise ValueError("Must pass idx_arr")
idx_arr = self.idx_arr
# Perform main computation
col_map = self.col_mapper.get_col_map(group_by=group_by)
if not returns_array:
if not returns_idx:
out = nb.reduce_mapped_nb(self.values, col_map, fill_value,
reduce_func_nb, *args)
else:
out = nb.reduce_mapped_to_idx_nb(self.values, col_map, idx_arr,
fill_value, reduce_func_nb,
*args)
else:
if not returns_idx:
out = nb.reduce_mapped_to_array_nb(self.values, col_map,
fill_value, reduce_func_nb,
*args)
else:
out = nb.reduce_mapped_to_idx_array_nb(self.values, col_map,
idx_arr, fill_value,
reduce_func_nb, *args)
# Perform post-processing
wrap_kwargs = merge_dicts(
dict(name_or_index='reduce' if not returns_array else None,
to_index=returns_idx and to_index,
fillna=-1 if returns_idx else None,
dtype=np.int_ if returns_idx else None), wrap_kwargs)
return self.wrapper.wrap_reduced(out, group_by=group_by, **wrap_kwargs)
@cached_method
def nth(self,
n: int,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return n-th element of each column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='nth'), wrap_kwargs)
return self.reduce(generic_nb.nth_reduce_nb,
n,
returns_array=False,
returns_idx=False,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def nth_index(self,
n: int,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return index of n-th element of each column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='nth_index'), wrap_kwargs)
return self.reduce(generic_nb.nth_index_reduce_nb,
n,
returns_array=False,
returns_idx=True,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def min(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return min by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='min'), wrap_kwargs)
return self.reduce(generic_nb.min_reduce_nb,
returns_array=False,
returns_idx=False,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def max(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return max by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='max'), wrap_kwargs)
return self.reduce(generic_nb.max_reduce_nb,
returns_array=False,
returns_idx=False,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def mean(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return mean by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='mean'), wrap_kwargs)
return self.reduce(generic_nb.mean_reduce_nb,
returns_array=False,
returns_idx=False,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def median(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return median by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='median'), wrap_kwargs)
return self.reduce(generic_nb.median_reduce_nb,
returns_array=False,
returns_idx=False,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def std(self,
ddof: int = 1,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return std by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='std'), wrap_kwargs)
return self.reduce(generic_nb.std_reduce_nb,
ddof,
returns_array=False,
returns_idx=False,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def sum(self,
fill_value: tp.Scalar = 0.,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return sum by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='sum'), wrap_kwargs)
return self.reduce(generic_nb.sum_reduce_nb,
fill_value=fill_value,
returns_array=False,
returns_idx=False,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def idxmin(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return index of min by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='idxmin'), wrap_kwargs)
return self.reduce(generic_nb.argmin_reduce_nb,
returns_array=False,
returns_idx=True,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def idxmax(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Return index of max by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='idxmax'), wrap_kwargs)
return self.reduce(generic_nb.argmax_reduce_nb,
returns_array=False,
returns_idx=True,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def describe(self,
percentiles: tp.Optional[tp.ArrayLike] = None,
ddof: int = 1,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.SeriesFrame:
"""Return statistics by column/group."""
if percentiles is not None:
percentiles = to_1d_array(percentiles)
else:
percentiles = np.array([0.25, 0.5, 0.75])
percentiles = percentiles.tolist()
if 0.5 not in percentiles:
percentiles.append(0.5)
percentiles = np.unique(percentiles)
perc_formatted = pd.io.formats.format.format_percentiles(percentiles)
index = pd.Index(
['count', 'mean', 'std', 'min', *perc_formatted, 'max'])
wrap_kwargs = merge_dicts(dict(name_or_index=index), wrap_kwargs)
out = self.reduce(generic_nb.describe_reduce_nb,
percentiles,
ddof,
returns_array=True,
returns_idx=False,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
if isinstance(out, pd.DataFrame):
out.loc['count'].fillna(0., inplace=True)
else:
if np.isnan(out.loc['count']):
out.loc['count'] = 0.
return out
@cached_method
def count(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None) -> tp.MaybeSeries:
"""Return number of values by column/group."""
wrap_kwargs = merge_dicts(dict(name_or_index='count'), wrap_kwargs)
return self.wrapper.wrap_reduced(
self.col_mapper.get_col_map(group_by=group_by)[1],
group_by=group_by,
**wrap_kwargs)
@cached_method
def value_counts(self,
normalize: bool = False,
sort_uniques: bool = True,
sort: bool = False,
ascending: bool = False,
dropna: bool = False,
group_by: tp.GroupByLike = None,
mapping: tp.Optional[tp.MappingLike] = None,
incl_all_keys: bool = False,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.SeriesFrame:
"""See `vectorbt.generic.accessors.GenericAccessor.value_counts`.
!!! note
Does not take into account missing values."""
if mapping is None:
mapping = self.mapping
if isinstance(mapping, str):
if mapping.lower() == 'index':
mapping = self.wrapper.index
elif mapping.lower() == 'columns':
mapping = self.wrapper.columns
mapping = to_mapping(mapping)
mapped_codes, mapped_uniques = pd.factorize(self.values,
sort=False,
na_sentinel=None)
col_map = self.col_mapper.get_col_map(group_by=group_by)
value_counts = nb.mapped_value_counts_nb(mapped_codes,
len(mapped_uniques), col_map)
if incl_all_keys and mapping is not None:
missing_keys = []
for x in mapping:
if pd.isnull(x) and pd.isnull(mapped_uniques).any():
continue
if x not in mapped_uniques:
missing_keys.append(x)
value_counts = np.vstack(
(value_counts,
np.full((len(missing_keys), value_counts.shape[1]), 0)))
mapped_uniques = np.concatenate(
(mapped_uniques, np.array(missing_keys)))
nan_mask = np.isnan(mapped_uniques)
if dropna:
value_counts = value_counts[~nan_mask]
mapped_uniques = mapped_uniques[~nan_mask]
if sort_uniques:
new_indices = mapped_uniques.argsort()
value_counts = value_counts[new_indices]
mapped_uniques = mapped_uniques[new_indices]
value_counts_sum = value_counts.sum(axis=1)
if normalize:
value_counts = value_counts / value_counts_sum.sum()
if sort:
if ascending:
new_indices = value_counts_sum.argsort()
else:
new_indices = (-value_counts_sum).argsort()
value_counts = value_counts[new_indices]
mapped_uniques = mapped_uniques[new_indices]
value_counts_pd = self.wrapper.wrap(value_counts,
index=mapped_uniques,
group_by=group_by,
**merge_dicts({}, wrap_kwargs))
if mapping is not None:
value_counts_pd.index = apply_mapping(value_counts_pd.index,
mapping, **kwargs)
return value_counts_pd
@cached_method
def apply_mapping(self: MappedArrayT,
mapping: tp.Optional[tp.MappingLike] = None,
**kwargs) -> MappedArrayT:
"""Apply mapping on each element."""
if mapping is None:
mapping = self.mapping
if isinstance(mapping, str):
if mapping.lower() == 'index':
mapping = self.wrapper.index
elif mapping.lower() == 'columns':
mapping = self.wrapper.columns
mapping = to_mapping(mapping)
return self.replace(mapped_arr=apply_mapping(self.values, mapping),
**kwargs)
def to_index(self):
"""Convert to index."""
return self.wrapper.index[self.values]
# ############# Stats ############# #
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `MappedArray.stats`.
Merges `vectorbt.generic.stats_builder.StatsBuilderMixin.stats_defaults` and
`mapped_array.stats` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
mapped_array_stats_cfg = settings['mapped_array']['stats']
return merge_dicts(StatsBuilderMixin.stats_defaults.__get__(self),
mapped_array_stats_cfg)
_metrics: tp.ClassVar[Config] = Config(dict(
start=dict(title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'),
end=dict(title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'),
period=dict(title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper'),
count=dict(title='Count', calc_func='count', tags='mapped_array'),
mean=dict(title='Mean',
calc_func='mean',
inv_check_has_mapping=True,
tags=['mapped_array', 'describe']),
std=dict(title='Std',
calc_func='std',
inv_check_has_mapping=True,
tags=['mapped_array', 'describe']),
min=dict(title='Min',
calc_func='min',
inv_check_has_mapping=True,
tags=['mapped_array', 'describe']),
median=dict(title='Median',
calc_func='median',
inv_check_has_mapping=True,
tags=['mapped_array', 'describe']),
max=dict(title='Max',
calc_func='max',
inv_check_has_mapping=True,
tags=['mapped_array', 'describe']),
idx_min=dict(title='Min Index',
calc_func='idxmin',
inv_check_has_mapping=True,
agg_func=None,
tags=['mapped_array', 'index']),
idx_max=dict(title='Max Index',
calc_func='idxmax',
inv_check_has_mapping=True,
agg_func=None,
tags=['mapped_array', 'index']),
value_counts=dict(title='Value Counts',
calc_func=lambda value_counts: to_dict(
value_counts, orient='index_series'),
resolve_value_counts=True,
check_has_mapping=True,
tags=['mapped_array', 'value_counts'])),
copy_kwargs=dict(copy_mode='deep'))
@property
def metrics(self) -> Config:
return self._metrics
# ############# Plotting ############# #
def histplot(self,
group_by: tp.GroupByLike = None,
**kwargs) -> tp.BaseFigure: # pragma: no cover
"""Plot histogram by column/group."""
return self.to_pd(group_by=group_by,
ignore_index=True).vbt.histplot(**kwargs)
def boxplot(self,
group_by: tp.GroupByLike = None,
**kwargs) -> tp.BaseFigure: # pragma: no cover
"""Plot box plot by column/group."""
return self.to_pd(group_by=group_by,
ignore_index=True).vbt.boxplot(**kwargs)
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `MappedArray.plots`.
Merges `vectorbt.generic.plots_builder.PlotsBuilderMixin.plots_defaults` and
`mapped_array.plots` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
mapped_array_plots_cfg = settings['mapped_array']['plots']
return merge_dicts(PlotsBuilderMixin.plots_defaults.__get__(self),
mapped_array_plots_cfg)
_subplots: tp.ClassVar[Config] = Config(
dict(to_pd_plot=dict(check_is_not_grouped=True,
plot_func='to_pd.vbt.plot',
pass_trace_names=False,
tags='mapped_array')),
copy_kwargs=dict(copy_mode='deep'))
@property
def subplots(self) -> Config:
return self._subplots
for k in names:
settings[k] = getattr(this_module, k)
Config(settings).save(fname, **kwargs)
def load(fname, names=__all__, **kwargs):
"""Load settings from a file."""
settings = Config.load(fname, **kwargs)
for k in names:
setattr(this_module, k, settings[k])
__pdoc__ = {}
# Color schema
color_schema = Config(increasing="#1b9e76", decreasing="#d95f02")
"""_"""
__pdoc__['color_schema'] = f"""Color schema.
```plaintext
{json.dumps(color_schema, indent=2, default=str)}
```
"""
# Contrast color schema
contrast_color_schema = Config(blue="#4285F4",
orange="#FFAA00",
green="#37B13F",
red="#EA4335",
gray="#E2E2E2")
__pdoc__ = {}
orders_field_config = Config(
dict(
dtype=order_dt,
settings=dict(
id=dict(
title='Order Id'
),
size=dict(
title='Size'
),
price=dict(
title='Price'
),
fees=dict(
title='Fees'
),
side=dict(
title='Side',
mapping=OrderSide
)
)
),
readonly=True,
as_attrs=False
)
"""_"""
__pdoc__['orders_field_config'] = f"""Field config for `Orders`.
"""Common configurations for indicators."""
from vectorbt.utils.config import Config
flex_elem_param_config = Config(
dict(
is_array_like=
True, # passing a NumPy array means passing one value, for multiple use list
bc_to_input=True, # broadcast to input
broadcast_kwargs=dict(
keep_raw=
True # keep original shape for flexible indexing to save memory
)))
"""Config for flexible element-wise parameters."""
flex_col_param_config = Config(
dict(
is_array_like=True,
bc_to_input=1, # broadcast to axis 1 (columns)
per_column=True, # display one parameter per column
broadcast_kwargs=dict(keep_raw=True)))
"""Config for flexible column-wise parameters."""
class Orders(Records):
"""Extends `Records` for working with order records."""
@property
def field_config(self) -> Config:
return self._field_config
def __init__(self,
wrapper: ArrayWrapper,
records_arr: tp.RecordArray,
close: tp.Optional[tp.ArrayLike] = None,
**kwargs) -> None:
Records.__init__(
self,
wrapper,
records_arr,
close=close,
**kwargs
)
self._close = close
def indexing_func(self: OrdersT, pd_indexing_func: tp.PandasIndexingFunc, **kwargs) -> OrdersT:
"""Perform indexing on `Orders`."""
new_wrapper, new_records_arr, group_idxs, col_idxs = \
Records.indexing_func_meta(self, pd_indexing_func, **kwargs)
if self.close is not None:
new_close = new_wrapper.wrap(to_2d_array(self.close)[:, col_idxs], group_by=False)
else:
new_close = None
return self.replace(
wrapper=new_wrapper,
records_arr=new_records_arr,
close=new_close
)
@property
def close(self) -> tp.Optional[tp.SeriesFrame]:
"""Reference price such as close (optional)."""
return self._close
# ############# Stats ############# #
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `Orders.stats`.
Merges `vectorbt.records.base.Records.stats_defaults` and
`orders.stats` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
orders_stats_cfg = settings['orders']['stats']
return merge_dicts(
Records.stats_defaults.__get__(self),
orders_stats_cfg
)
_metrics: tp.ClassVar[Config] = Config(
dict(
start=dict(
title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'
),
end=dict(
title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'
),
period=dict(
title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper'
),
total_records=dict(
title='Total Records',
calc_func='count',
tags='records'
),
total_buy_orders=dict(
title='Total Buy Orders',
calc_func='buy.count',
tags=['orders', 'buy']
),
total_sell_orders=dict(
title='Total Sell Orders',
calc_func='sell.count',
tags=['orders', 'sell']
),
min_size=dict(
title='Min Size',
calc_func='size.min',
tags=['orders', 'size']
),
max_size=dict(
title='Max Size',
calc_func='size.max',
tags=['orders', 'size']
),
avg_size=dict(
title='Avg Size',
calc_func='size.mean',
tags=['orders', 'size']
),
avg_buy_size=dict(
title='Avg Buy Size',
calc_func='buy.size.mean',
tags=['orders', 'buy', 'size']
),
avg_sell_size=dict(
title='Avg Sell Size',
calc_func='sell.size.mean',
tags=['orders', 'sell', 'size']
),
avg_buy_price=dict(
title='Avg Buy Price',
calc_func='buy.price.mean',
tags=['orders', 'buy', 'price']
),
avg_sell_price=dict(
title='Avg Sell Price',
calc_func='sell.price.mean',
tags=['orders', 'sell', 'price']
),
total_fees=dict(
title='Total Fees',
calc_func='fees.sum',
tags=['orders', 'fees']
),
min_fees=dict(
title='Min Fees',
calc_func='fees.min',
tags=['orders', 'fees']
),
max_fees=dict(
title='Max Fees',
calc_func='fees.max',
tags=['orders', 'fees']
),
avg_fees=dict(
title='Avg Fees',
calc_func='fees.mean',
tags=['orders', 'fees']
),
avg_buy_fees=dict(
title='Avg Buy Fees',
calc_func='buy.fees.mean',
tags=['orders', 'buy', 'fees']
),
avg_sell_fees=dict(
title='Avg Sell Fees',
calc_func='sell.fees.mean',
tags=['orders', 'sell', 'fees']
),
),
copy_kwargs=dict(copy_mode='deep')
)
@property
def metrics(self) -> Config:
return self._metrics
# ############# Plotting ############# #
def plot(self,
column: tp.Optional[tp.Label] = None,
close_trace_kwargs: tp.KwargsLike = None,
buy_trace_kwargs: tp.KwargsLike = None,
sell_trace_kwargs: tp.KwargsLike = None,
add_trace_kwargs: tp.KwargsLike = None,
fig: tp.Optional[tp.BaseFigure] = None,
**layout_kwargs) -> tp.BaseFigure: # pragma: no cover
"""Plot orders.
Args:
column (str): Name of the column to plot.
close_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for `Orders.close`.
buy_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for "Buy" markers.
sell_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for "Sell" markers.
add_trace_kwargs (dict): Keyword arguments passed to `add_trace`.
fig (Figure or FigureWidget): Figure to add traces to.
**layout_kwargs: Keyword arguments for layout.
## Example
```python-repl
>>> import pandas as pd
>>> from datetime import datetime, timedelta
>>> import vectorbt as vbt
>>> price = pd.Series([1., 2., 3., 2., 1.], name='Price')
>>> price.index = [datetime(2020, 1, 1) + timedelta(days=i) for i in range(len(price))]
>>> size = pd.Series([1., 1., 1., 1., -1.])
>>> orders = vbt.Portfolio.from_orders(price, size).orders
>>> orders.plot()
```
"""
from vectorbt._settings import settings
plotting_cfg = settings['plotting']
self_col = self.select_one(column=column, group_by=False)
if close_trace_kwargs is None:
close_trace_kwargs = {}
close_trace_kwargs = merge_dicts(dict(
line=dict(
color=plotting_cfg['color_schema']['blue']
),
name='Close'
), close_trace_kwargs)
if buy_trace_kwargs is None:
buy_trace_kwargs = {}
if sell_trace_kwargs is None:
sell_trace_kwargs = {}
if add_trace_kwargs is None:
add_trace_kwargs = {}
if fig is None:
fig = make_figure()
fig.update_layout(**layout_kwargs)
# Plot price
if self_col.close is not None:
fig = self_col.close.vbt.plot(trace_kwargs=close_trace_kwargs, add_trace_kwargs=add_trace_kwargs, fig=fig)
if self_col.count() > 0:
# Extract information
id_ = self_col.get_field_arr('id')
id_title = self_col.get_field_title('id')
idx = self_col.get_map_field_to_index('idx')
idx_title = self_col.get_field_title('idx')
size = self_col.get_field_arr('size')
size_title = self_col.get_field_title('size')
fees = self_col.get_field_arr('fees')
fees_title = self_col.get_field_title('fees')
price = self_col.get_field_arr('price')
price_title = self_col.get_field_title('price')
side = self_col.get_field_arr('side')
buy_mask = side == OrderSide.Buy
if buy_mask.any():
# Plot buy markers
buy_customdata = np.stack((
id_[buy_mask],
size[buy_mask],
fees[buy_mask]
), axis=1)
buy_scatter = go.Scatter(
x=idx[buy_mask],
y=price[buy_mask],
mode='markers',
marker=dict(
symbol='triangle-up',
color=plotting_cfg['contrast_color_schema']['green'],
size=8,
line=dict(
width=1,
color=adjust_lightness(plotting_cfg['contrast_color_schema']['green'])
)
),
name='Buy',
customdata=buy_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{idx_title}: %{{x}}"
f"<br>{price_title}: %{{y}}"
f"<br>{size_title}: %{{customdata[1]:.6f}}"
f"<br>{fees_title}: %{{customdata[2]:.6f}}"
)
buy_scatter.update(**buy_trace_kwargs)
fig.add_trace(buy_scatter, **add_trace_kwargs)
sell_mask = side == OrderSide.Sell
if sell_mask.any():
# Plot sell markers
sell_customdata = np.stack((
id_[sell_mask],
size[sell_mask],
fees[sell_mask]
), axis=1)
sell_scatter = go.Scatter(
x=idx[sell_mask],
y=price[sell_mask],
mode='markers',
marker=dict(
symbol='triangle-down',
color=plotting_cfg['contrast_color_schema']['red'],
size=8,
line=dict(
width=1,
color=adjust_lightness(plotting_cfg['contrast_color_schema']['red'])
)
),
name='Sell',
customdata=sell_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{idx_title}: %{{x}}"
f"<br>{price_title}: %{{y}}"
f"<br>{size_title}: %{{customdata[1]:.6f}}"
f"<br>{fees_title}: %{{customdata[2]:.6f}}"
)
sell_scatter.update(**sell_trace_kwargs)
fig.add_trace(sell_scatter, **add_trace_kwargs)
return fig
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `Orders.plots`.
Merges `vectorbt.records.base.Records.plots_defaults` and
`orders.plots` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
orders_plots_cfg = settings['orders']['plots']
return merge_dicts(
Records.plots_defaults.__get__(self),
orders_plots_cfg
)
_subplots: tp.ClassVar[Config] = Config(
dict(
plot=dict(
title="Orders",
yaxis_kwargs=dict(title="Price"),
check_is_not_grouped=True,
plot_func='plot',
tags='orders'
)
),
copy_kwargs=dict(copy_mode='deep')
)
@property
def subplots(self) -> Config:
return self._subplots
self.register_template(theme)
self['plotting']['color_schema'].update(self['plotting']['themes'][theme]['color_schema'])
self['plotting']['layout']['template'] = 'vbt_' + theme
def reset_theme(self) -> None:
"""Reset to default theme."""
self.set_theme('light')
settings = SettingsConfig(
dict(
config=Config( # flex
dict(
configured=Config( # flex
dict(
readonly=True
)
)
),
),
caching=dict(
enabled=True,
whitelist=[
CacheCondition(base_cls=ArrayWrapper),
CacheCondition(base_cls=ColumnGrouper),
CacheCondition(base_cls=ColumnMapper)
],
blacklist=[]
),
broadcasting=dict(
align_index=False,
"""Global defaults."""
from vectorbt.utils.config import Config
# Layout
layout = Config(frozen=False,
autosize=False,
width=700,
height=300,
margin=dict(b=30, t=30),
hovermode='closest',
colorway=[
"#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
"#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"
])
"""Default Plotly layout."""
# Portfolio
portfolio = Config(init_capital=1.,
fees=0.,
slippage=0.,
year_freq='1Y',
risk_free=0.,
required_return=0.,
cutoff=0.05)
"""Default portfolio parameters."""
# Broadcasting
broadcasting = Config(index_from='strict',
columns_from='stack',
ignore_single=True,
binary_magic_config = Config(
{
'__eq__': dict(func=np.equal),
'__ne__': dict(func=np.not_equal),
'__lt__': dict(func=np.less),
'__gt__': dict(func=np.greater),
'__le__': dict(func=np.less_equal),
'__ge__': dict(func=np.greater_equal),
# arithmetic ops
'__add__': dict(func=np.add),
'__sub__': dict(func=np.subtract),
'__mul__': dict(func=np.multiply),
'__pow__': dict(func=np.power),
'__mod__': dict(func=np.mod),
'__floordiv__': dict(func=np.floor_divide),
'__truediv__': dict(func=np.true_divide),
'__radd__': dict(func=lambda x, y: np.add(y, x)),
'__rsub__': dict(func=lambda x, y: np.subtract(y, x)),
'__rmul__': dict(func=lambda x, y: np.multiply(y, x)),
'__rpow__': dict(func=lambda x, y: np.power(y, x)),
'__rmod__': dict(func=lambda x, y: np.mod(y, x)),
'__rfloordiv__': dict(func=lambda x, y: np.floor_divide(y, x)),
'__rtruediv__': dict(func=lambda x, y: np.true_divide(y, x)),
# mask ops
'__and__': dict(func=np.bitwise_and),
'__or__': dict(func=np.bitwise_or),
'__xor__': dict(func=np.bitwise_xor),
'__rand__': dict(func=lambda x, y: np.bitwise_and(y, x)),
'__ror__': dict(func=lambda x, y: np.bitwise_or(y, x)),
'__rxor__': dict(func=lambda x, y: np.bitwise_xor(y, x))
},
readonly=True,
as_attrs=False)
class PlotsBuilderMixin(metaclass=MetaPlotsBuilderMixin):
"""Mixin that implements `PlotsBuilderMixin.plots`.
Required to be a subclass of `vectorbt.base.array_wrapper.Wrapping`."""
def __init__(self):
checks.assert_instance_of(self, Wrapping)
# Copy writeable attrs
self._subplots = self.__class__._subplots.copy()
@property
def writeable_attrs(self) -> tp.Set[str]:
"""Set of writeable attributes that will be saved/copied along with the config."""
return {'_subplots'}
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `PlotsBuilderMixin.plots`.
See `plots_builder` in `vectorbt._settings.settings`."""
from vectorbt._settings import settings
plots_builder_cfg = settings['plots_builder']
return merge_dicts(plots_builder_cfg,
dict(settings=dict(freq=self.wrapper.freq)))
_subplots: tp.ClassVar[Config] = Config(dict(),
copy_kwargs=dict(copy_mode='deep'))
@property
def subplots(self) -> Config:
"""Subplots supported by `${cls_name}`.
```json
${subplots}
```
Returns `${cls_name}._subplots`, which gets (deep) copied upon creation of each instance.
Thus, changing this config won't affect the class.
To change subplots, you can either change the config in-place, override this property,
or overwrite the instance variable `${cls_name}._subplots`."""
return self._subplots
def plots(self,
subplots: tp.Optional[tp.MaybeIterable[tp.Union[str, tp.Tuple[
str, tp.Kwargs]]]] = None,
tags: tp.Optional[tp.MaybeIterable[str]] = None,
column: tp.Optional[tp.Label] = None,
group_by: tp.GroupByLike = None,
silence_warnings: tp.Optional[bool] = None,
template_mapping: tp.Optional[tp.Mapping] = None,
settings: tp.KwargsLike = None,
filters: tp.KwargsLike = None,
subplot_settings: tp.KwargsLike = None,
show_titles: bool = None,
hide_id_labels: bool = None,
group_id_labels: bool = None,
make_subplots_kwargs: tp.KwargsLike = None,
**layout_kwargs) -> tp.Optional[tp.BaseFigure]:
"""Plot various parts of this object.
Args:
subplots (str, tuple, iterable, or dict): Subplots to plot.
Each element can be either:
* a subplot name (see keys in `PlotsBuilderMixin.subplots`)
* a tuple of a subplot name and a settings dict as in `PlotsBuilderMixin.subplots`.
The settings dict can contain the following keys:
* `title`: Title of the subplot. Defaults to the name.
* `plot_func` (required): Plotting function for custom subplots.
Should write the supplied figure `fig` in-place and can return anything (it won't be used).
* `xaxis_kwargs`: Layout keyword arguments for the x-axis. Defaults to `dict(title='Index')`.
* `yaxis_kwargs`: Layout keyword arguments for the y-axis. Defaults to empty dict.
* `tags`, `check_{filter}`, `inv_check_{filter}`, `resolve_plot_func`, `pass_{arg}`,
`resolve_path_{arg}`, `resolve_{arg}` and `template_mapping`:
The same as in `vectorbt.generic.stats_builder.StatsBuilderMixin` for `calc_func`.
* Any other keyword argument that overrides the settings or is passed directly to `plot_func`.
If `resolve_plot_func` is True, the plotting function may "request" any of the
following arguments by accepting them or if `pass_{arg}` was found in the settings dict:
* Each of `vectorbt.utils.attr_.AttrResolver.self_aliases`: original object
(ungrouped, with no column selected)
* `group_by`: won't be passed if it was used in resolving the first attribute of `plot_func`
specified as a path, use `pass_group_by=True` to pass anyway
* `column`
* `subplot_name`
* `trace_names`: list with the subplot name, can't be used in templates
* `add_trace_kwargs`: dict with subplot row and column index
* `xref`
* `yref`
* `xaxis`
* `yaxis`
* `x_domain`
* `y_domain`
* `fig`
* `silence_warnings`
* Any argument from `settings`
* Any attribute of this object if it meant to be resolved
(see `vectorbt.utils.attr_.AttrResolver.resolve_attr`)
!!! note
Layout-related resolution arguments such as `add_trace_kwargs` are unavailable
before filtering and thus cannot be used in any templates but can still be overridden.
Pass `subplots='all'` to plot all supported subplots.
tags (str or iterable): See `tags` in `vectorbt.generic.stats_builder.StatsBuilderMixin`.
column (str): See `column` in `vectorbt.generic.stats_builder.StatsBuilderMixin`.
group_by (any): See `group_by` in `vectorbt.generic.stats_builder.StatsBuilderMixin`.
silence_warnings (bool): See `silence_warnings` in `vectorbt.generic.stats_builder.StatsBuilderMixin`.
template_mapping (mapping): See `template_mapping` in `vectorbt.generic.stats_builder.StatsBuilderMixin`.
Applied on `settings`, `make_subplots_kwargs`, and `layout_kwargs`, and then on each subplot settings.
filters (dict): See `filters` in `vectorbt.generic.stats_builder.StatsBuilderMixin`.
settings (dict): See `settings` in `vectorbt.generic.stats_builder.StatsBuilderMixin`.
subplot_settings (dict): See `metric_settings` in `vectorbt.generic.stats_builder.StatsBuilderMixin`.
show_titles (bool): Whether to show the title of each subplot.
hide_id_labels (bool): Whether to hide identical legend labels.
Two labels are identical if their name, marker style and line style match.
group_id_labels (bool): Whether to group identical legend labels.
make_subplots_kwargs (dict): Keyword arguments passed to `plotly.subplots.make_subplots`.
**layout_kwargs: Keyword arguments used to update the layout of the figure.
!!! note
`PlotsBuilderMixin` and `vectorbt.generic.stats_builder.StatsBuilderMixin` are very similar.
Some artifacts follow the same concept, just named differently:
* `plots_defaults` vs `stats_defaults`
* `subplots` vs `metrics`
* `subplot_settings` vs `metric_settings`
See further notes under `vectorbt.generic.stats_builder.StatsBuilderMixin`.
Usage:
See `vectorbt.portfolio.base` for examples.
"""
from vectorbt._settings import settings as _settings
plotting_cfg = _settings['plotting']
# Resolve defaults
if silence_warnings is None:
silence_warnings = self.plots_defaults['silence_warnings']
if show_titles is None:
show_titles = self.plots_defaults['show_titles']
if hide_id_labels is None:
hide_id_labels = self.plots_defaults['hide_id_labels']
if group_id_labels is None:
group_id_labels = self.plots_defaults['group_id_labels']
template_mapping = merge_dicts(self.plots_defaults['template_mapping'],
template_mapping)
filters = merge_dicts(self.plots_defaults['filters'], filters)
settings = merge_dicts(self.plots_defaults['settings'], settings)
subplot_settings = merge_dicts(self.plots_defaults['subplot_settings'],
subplot_settings)
make_subplots_kwargs = merge_dicts(
self.plots_defaults['make_subplots_kwargs'], make_subplots_kwargs)
layout_kwargs = merge_dicts(self.plots_defaults['layout_kwargs'],
layout_kwargs)
# Replace templates globally (not used at subplot level)
if len(template_mapping) > 0:
sub_settings = deep_substitute(settings, mapping=template_mapping)
sub_make_subplots_kwargs = deep_substitute(
make_subplots_kwargs, mapping=template_mapping)
sub_layout_kwargs = deep_substitute(layout_kwargs,
mapping=template_mapping)
else:
sub_settings = settings
sub_make_subplots_kwargs = make_subplots_kwargs
sub_layout_kwargs = layout_kwargs
# Resolve self
reself = self.resolve_self(cond_kwargs=sub_settings,
impacts_caching=False,
silence_warnings=silence_warnings)
# Prepare subplots
if subplots is None:
subplots = reself.plots_defaults['subplots']
if subplots == 'all':
subplots = reself.subplots
if isinstance(subplots, dict):
subplots = list(subplots.items())
if isinstance(subplots, (str, tuple)):
subplots = [subplots]
# Prepare tags
if tags is None:
tags = reself.plots_defaults['tags']
if isinstance(tags, str) and tags == 'all':
tags = None
if isinstance(tags, (str, tuple)):
tags = [tags]
# Bring to the same shape
new_subplots = []
for i, subplot in enumerate(subplots):
if isinstance(subplot, str):
subplot = (subplot, reself.subplots[subplot])
if not isinstance(subplot, tuple):
raise TypeError(
f"Subplot at index {i} must be either a string or a tuple")
new_subplots.append(subplot)
subplots = new_subplots
# Handle duplicate names
subplot_counts = Counter(list(map(lambda x: x[0], subplots)))
subplot_i = {k: -1 for k in subplot_counts.keys()}
subplots_dct = {}
for i, (subplot_name, _subplot_settings) in enumerate(subplots):
if subplot_counts[subplot_name] > 1:
subplot_i[subplot_name] += 1
subplot_name = subplot_name + '_' + str(
subplot_i[subplot_name])
subplots_dct[subplot_name] = _subplot_settings
# Check subplot_settings
missed_keys = set(subplot_settings.keys()).difference(
set(subplots_dct.keys()))
if len(missed_keys) > 0:
raise ValueError(
f"Keys {missed_keys} in subplot_settings could not be matched with any subplot"
)
# Merge settings
opt_arg_names_dct = {}
custom_arg_names_dct = {}
resolved_self_dct = {}
mapping_dct = {}
for subplot_name, _subplot_settings in list(subplots_dct.items()):
opt_settings = merge_dicts(
{name: reself
for name in reself.self_aliases},
dict(column=column,
group_by=group_by,
subplot_name=subplot_name,
trace_names=[subplot_name],
silence_warnings=silence_warnings), settings)
_subplot_settings = _subplot_settings.copy()
passed_subplot_settings = subplot_settings.get(subplot_name, {})
merged_settings = merge_dicts(opt_settings, _subplot_settings,
passed_subplot_settings)
subplot_template_mapping = merged_settings.pop(
'template_mapping', {})
template_mapping_merged = merge_dicts(template_mapping,
subplot_template_mapping)
template_mapping_merged = deep_substitute(template_mapping_merged,
mapping=merged_settings)
mapping = merge_dicts(template_mapping_merged, merged_settings)
# safe because we will use deep_substitute again once layout params are known
merged_settings = deep_substitute(merged_settings,
mapping=mapping,
safe=True)
# Filter by tag
if tags is not None:
in_tags = merged_settings.get('tags', None)
if in_tags is None or not match_tags(tags, in_tags):
subplots_dct.pop(subplot_name, None)
continue
custom_arg_names = set(_subplot_settings.keys()).union(
set(passed_subplot_settings.keys()))
opt_arg_names = set(opt_settings.keys())
custom_reself = reself.resolve_self(
cond_kwargs=merged_settings,
custom_arg_names=custom_arg_names,
impacts_caching=True,
silence_warnings=merged_settings['silence_warnings'])
subplots_dct[subplot_name] = merged_settings
custom_arg_names_dct[subplot_name] = custom_arg_names
opt_arg_names_dct[subplot_name] = opt_arg_names
resolved_self_dct[subplot_name] = custom_reself
mapping_dct[subplot_name] = mapping
# Filter subplots
for subplot_name, _subplot_settings in list(subplots_dct.items()):
custom_reself = resolved_self_dct[subplot_name]
mapping = mapping_dct[subplot_name]
_silence_warnings = _subplot_settings.get('silence_warnings')
subplot_filters = set()
for k in _subplot_settings.keys():
filter_name = None
if k.startswith('check_'):
filter_name = k[len('check_'):]
elif k.startswith('inv_check_'):
filter_name = k[len('inv_check_'):]
if filter_name is not None:
if filter_name not in filters:
raise ValueError(
f"Metric '{subplot_name}' requires filter '{filter_name}'"
)
subplot_filters.add(filter_name)
for filter_name in subplot_filters:
filter_settings = filters[filter_name]
_filter_settings = deep_substitute(filter_settings,
mapping=mapping)
filter_func = _filter_settings['filter_func']
warning_message = _filter_settings.get('warning_message', None)
inv_warning_message = _filter_settings.get(
'inv_warning_message', None)
to_check = _subplot_settings.get('check_' + filter_name, False)
inv_to_check = _subplot_settings.get(
'inv_check_' + filter_name, False)
if to_check or inv_to_check:
whether_true = filter_func(custom_reself,
_subplot_settings)
to_remove = (to_check
and not whether_true) or (inv_to_check
and whether_true)
if to_remove:
if to_check and warning_message is not None and not _silence_warnings:
warnings.warn(warning_message)
if inv_to_check and inv_warning_message is not None and not _silence_warnings:
warnings.warn(inv_warning_message)
subplots_dct.pop(subplot_name, None)
custom_arg_names_dct.pop(subplot_name, None)
opt_arg_names_dct.pop(subplot_name, None)
resolved_self_dct.pop(subplot_name, None)
mapping_dct.pop(subplot_name, None)
break
# Any subplots left?
if len(subplots_dct) == 0:
if not silence_warnings:
warnings.warn("No subplots to plot", stacklevel=2)
return None
# Set up figure
rows = sub_make_subplots_kwargs.pop('rows', len(subplots_dct))
cols = sub_make_subplots_kwargs.pop('cols', 1)
specs = sub_make_subplots_kwargs.pop('specs', [[{}
for _ in range(cols)]
for _ in range(rows)])
row_col_tuples = []
for row, row_spec in enumerate(specs):
for col, col_spec in enumerate(row_spec):
if col_spec is not None:
row_col_tuples.append((row + 1, col + 1))
shared_xaxes = sub_make_subplots_kwargs.pop('shared_xaxes', True)
shared_yaxes = sub_make_subplots_kwargs.pop('shared_yaxes', False)
default_height = plotting_cfg['layout']['height']
default_width = plotting_cfg['layout']['width'] + 50
min_space = 10 # space between subplots with no axis sharing
max_title_spacing = 30
max_xaxis_spacing = 50
max_yaxis_spacing = 100
legend_height = 50
if show_titles:
title_spacing = max_title_spacing
else:
title_spacing = 0
if not shared_xaxes and rows > 1:
xaxis_spacing = max_xaxis_spacing
else:
xaxis_spacing = 0
if not shared_yaxes and cols > 1:
yaxis_spacing = max_yaxis_spacing
else:
yaxis_spacing = 0
if 'height' in sub_layout_kwargs:
height = sub_layout_kwargs.pop('height')
else:
height = default_height + title_spacing
if rows > 1:
height *= rows
height += min_space * rows - min_space
height += legend_height - legend_height * rows
if shared_xaxes:
height += max_xaxis_spacing - max_xaxis_spacing * rows
if 'width' in sub_layout_kwargs:
width = sub_layout_kwargs.pop('width')
else:
width = default_width
if cols > 1:
width *= cols
width += min_space * cols - min_space
if shared_yaxes:
width += max_yaxis_spacing - max_yaxis_spacing * cols
if height is not None:
if 'vertical_spacing' in sub_make_subplots_kwargs:
vertical_spacing = sub_make_subplots_kwargs.pop(
'vertical_spacing')
else:
vertical_spacing = min_space + title_spacing + xaxis_spacing
if vertical_spacing is not None and vertical_spacing > 1:
vertical_spacing /= height
legend_y = 1 + (min_space + title_spacing) / height
else:
vertical_spacing = sub_make_subplots_kwargs.pop(
'vertical_spacing', None)
legend_y = 1.02
if width is not None:
if 'horizontal_spacing' in sub_make_subplots_kwargs:
horizontal_spacing = sub_make_subplots_kwargs.pop(
'horizontal_spacing')
else:
horizontal_spacing = min_space + yaxis_spacing
if horizontal_spacing is not None and horizontal_spacing > 1:
horizontal_spacing /= width
else:
horizontal_spacing = sub_make_subplots_kwargs.pop(
'horizontal_spacing', None)
if show_titles:
_subplot_titles = []
for i in range(len(subplots_dct)):
_subplot_titles.append('$title_' + str(i))
else:
_subplot_titles = None
fig = make_subplots(rows=rows,
cols=cols,
specs=specs,
shared_xaxes=shared_xaxes,
shared_yaxes=shared_yaxes,
subplot_titles=_subplot_titles,
vertical_spacing=vertical_spacing,
horizontal_spacing=horizontal_spacing,
**sub_make_subplots_kwargs)
sub_layout_kwargs = merge_dicts(
dict(showlegend=True,
width=width,
height=height,
legend=dict(orientation="h",
yanchor="bottom",
y=legend_y,
xanchor="right",
x=1,
traceorder='normal')), sub_layout_kwargs)
fig.update_layout(
**sub_layout_kwargs) # final destination for sub_layout_kwargs
# Plot subplots
arg_cache_dct = {}
for i, (subplot_name,
_subplot_settings) in enumerate(subplots_dct.items()):
try:
final_kwargs = _subplot_settings.copy()
opt_arg_names = opt_arg_names_dct[subplot_name]
custom_arg_names = custom_arg_names_dct[subplot_name]
custom_reself = resolved_self_dct[subplot_name]
mapping = mapping_dct[subplot_name]
# Compute figure artifacts
row, col = row_col_tuples[i]
xref = 'x' if i == 0 else 'x' + str(i + 1)
yref = 'y' if i == 0 else 'y' + str(i + 1)
xaxis = 'xaxis' + xref[1:]
yaxis = 'yaxis' + yref[1:]
x_domain = get_domain(xref, fig)
y_domain = get_domain(yref, fig)
subplot_layout_kwargs = dict(
add_trace_kwargs=dict(row=row, col=col),
xref=xref,
yref=yref,
xaxis=xaxis,
yaxis=yaxis,
x_domain=x_domain,
y_domain=y_domain,
fig=fig,
pass_fig=True # force passing fig
)
for k in subplot_layout_kwargs:
opt_arg_names.add(k)
if k in final_kwargs:
custom_arg_names.add(k)
final_kwargs = merge_dicts(subplot_layout_kwargs, final_kwargs)
mapping = merge_dicts(subplot_layout_kwargs, mapping)
final_kwargs = deep_substitute(final_kwargs, mapping=mapping)
# Clean up keys
for k, v in list(final_kwargs.items()):
if k.startswith('check_') or k.startswith(
'inv_check_') or k in ('tags', ):
final_kwargs.pop(k, None)
# Get subplot-specific values
_column = final_kwargs.get('column')
_group_by = final_kwargs.get('group_by')
_silence_warnings = final_kwargs.get('silence_warnings')
title = final_kwargs.pop('title', subplot_name)
plot_func = final_kwargs.pop('plot_func', None)
xaxis_kwargs = final_kwargs.pop('xaxis_kwargs', None)
yaxis_kwargs = final_kwargs.pop('yaxis_kwargs', None)
resolve_plot_func = final_kwargs.pop('resolve_plot_func', True)
use_caching = final_kwargs.pop('use_caching', True)
if plot_func is not None:
# Resolve plot_func
if resolve_plot_func:
if not callable(plot_func):
passed_kwargs_out = {}
def _getattr_func(
obj: tp.Any,
attr: str,
args: tp.ArgsLike = None,
kwargs: tp.KwargsLike = None,
call_attr: bool = True,
_final_kwargs: tp.Kwargs = final_kwargs,
_opt_arg_names: tp.Set[str] = opt_arg_names,
_custom_arg_names: tp.
Set[str] = custom_arg_names,
_arg_cache_dct: tp.Kwargs = arg_cache_dct
) -> tp.Any:
if attr in final_kwargs:
return final_kwargs[attr]
if args is None:
args = ()
if kwargs is None:
kwargs = {}
if obj is custom_reself and _final_kwargs.pop(
'resolve_path_' + attr, True):
if call_attr:
return custom_reself.resolve_attr(
attr,
args=args,
cond_kwargs={
k: v
for k, v in
_final_kwargs.items()
if k in _opt_arg_names
},
kwargs=kwargs,
custom_arg_names=_custom_arg_names,
cache_dct=_arg_cache_dct,
use_caching=use_caching,
passed_kwargs_out=passed_kwargs_out
)
return getattr(obj, attr)
out = getattr(obj, attr)
if callable(out) and call_attr:
return out(*args, **kwargs)
return out
plot_func = custom_reself.deep_getattr(
plot_func,
getattr_func=_getattr_func,
call_last_attr=False)
if 'group_by' in passed_kwargs_out:
if 'pass_group_by' not in final_kwargs:
final_kwargs.pop('group_by', None)
if not callable(plot_func):
raise TypeError("plot_func must be callable")
# Resolve arguments
func_arg_names = get_func_arg_names(plot_func)
for k in func_arg_names:
if k not in final_kwargs:
if final_kwargs.pop('resolve_' + k, False):
try:
arg_out = custom_reself.resolve_attr(
k,
cond_kwargs=final_kwargs,
custom_arg_names=custom_arg_names,
cache_dct=arg_cache_dct,
use_caching=use_caching)
except AttributeError:
continue
final_kwargs[k] = arg_out
for k in list(final_kwargs.keys()):
if k in opt_arg_names:
if 'pass_' + k in final_kwargs:
if not final_kwargs.get(
'pass_' + k): # first priority
final_kwargs.pop(k, None)
elif k not in func_arg_names: # second priority
final_kwargs.pop(k, None)
for k in list(final_kwargs.keys()):
if k.startswith('pass_') or k.startswith(
'resolve_'):
final_kwargs.pop(k, None) # cleanup
# Call plot_func
plot_func(**final_kwargs)
else:
# Do not resolve plot_func
plot_func(custom_reself, _subplot_settings)
# Update global layout
for annotation in fig.layout.annotations:
if 'text' in annotation and annotation[
'text'] == '$title_' + str(i):
annotation['text'] = title
subplot_layout = dict()
subplot_layout[xaxis] = merge_dicts(dict(title='Index'),
xaxis_kwargs)
subplot_layout[yaxis] = merge_dicts(dict(), yaxis_kwargs)
fig.update_layout(**subplot_layout)
except Exception as e:
warnings.warn(f"Subplot '{subplot_name}' raised an exception",
stacklevel=2)
raise e
# Remove duplicate legend labels
found_ids = dict()
unique_idx = 0
for trace in fig.data:
if 'name' in trace:
name = trace['name']
else:
name = None
if 'marker' in trace:
marker = trace['marker']
else:
marker = {}
if 'symbol' in marker:
marker_symbol = marker['symbol']
else:
marker_symbol = None
if 'color' in marker:
marker_color = marker['color']
else:
marker_color = None
if 'line' in trace:
line = trace['line']
else:
line = {}
if 'dash' in line:
line_dash = line['dash']
else:
line_dash = None
if 'color' in line:
line_color = line['color']
else:
line_color = None
id = (name, marker_symbol, marker_color, line_dash, line_color)
if id in found_ids:
if hide_id_labels:
trace['showlegend'] = False
if group_id_labels:
trace['legendgroup'] = found_ids[id]
else:
if group_id_labels:
trace['legendgroup'] = unique_idx
found_ids[id] = unique_idx
unique_idx += 1
# Remove all except the last title if sharing the same axis
if shared_xaxes:
i = 0
for row in range(rows):
for col in range(cols):
if specs[row][col] is not None:
xaxis = 'xaxis' if i == 0 else 'xaxis' + str(i + 1)
if row < rows - 1:
fig.layout[xaxis]['title'] = None
i += 1
if shared_yaxes:
i = 0
for row in range(rows):
for col in range(cols):
if specs[row][col] is not None:
yaxis = 'yaxis' if i == 0 else 'yaxis' + str(i + 1)
if col > 0:
fig.layout[yaxis]['title'] = None
i += 1
# Return the figure
return fig
# ############# Docs ############# #
@classmethod
def build_subplots_doc(cls, source_cls: tp.Optional[type] = None) -> str:
"""Build subplots documentation."""
if source_cls is None:
source_cls = PlotsBuilderMixin
return string.Template(
inspect.cleandoc(get_dict_attr(source_cls,
'subplots').__doc__)).substitute({
'subplots':
cls.subplots.to_doc(),
'cls_name':
cls.__name__
})
@classmethod
def override_subplots_doc(cls,
__pdoc__: dict,
source_cls: tp.Optional[type] = None) -> None:
"""Call this method on each subclass that overrides `subplots`."""
__pdoc__[cls.__name__ +
'.subplots'] = cls.build_subplots_doc(source_cls=source_cls)
class Drawdowns(Ranges):
"""Extends `vectorbt.generic.ranges.Ranges` for working with drawdown records.
Requires `records_arr` to have all fields defined in `vectorbt.generic.enums.drawdown_dt`."""
@property
def field_config(self) -> Config:
return self._field_config
def __init__(self,
wrapper: ArrayWrapper,
records_arr: tp.RecordArray,
ts: tp.Optional[tp.ArrayLike] = None,
**kwargs) -> None:
Ranges.__init__(self, wrapper, records_arr, ts=ts, **kwargs)
self._ts = ts
def indexing_func(self: DrawdownsT,
pd_indexing_func: tp.PandasIndexingFunc,
**kwargs) -> DrawdownsT:
"""Perform indexing on `Drawdowns`."""
new_wrapper, new_records_arr, _, col_idxs = \
Ranges.indexing_func_meta(self, pd_indexing_func, **kwargs)
if self.ts is not None:
new_ts = new_wrapper.wrap(self.ts.values[:, col_idxs],
group_by=False)
else:
new_ts = None
return self.replace(wrapper=new_wrapper,
records_arr=new_records_arr,
ts=new_ts)
@classmethod
def from_ts(cls: tp.Type[DrawdownsT],
ts: tp.ArrayLike,
attach_ts: bool = True,
wrapper_kwargs: tp.KwargsLike = None,
**kwargs) -> DrawdownsT:
"""Build `Drawdowns` from time series `ts`.
`**kwargs` will be passed to `Drawdowns.__init__`."""
ts_pd = to_pd_array(ts)
records_arr = nb.get_drawdowns_nb(to_2d_array(ts_pd))
wrapper = ArrayWrapper.from_obj(ts_pd, **merge_dicts({},
wrapper_kwargs))
return cls(wrapper,
records_arr,
ts=ts_pd if attach_ts else None,
**kwargs)
@property
def ts(self) -> tp.Optional[tp.SeriesFrame]:
"""Original time series that records are built from (optional)."""
return self._ts
# ############# Drawdown ############# #
@cached_property
def drawdown(self) -> MappedArray:
"""See `vectorbt.generic.nb.dd_drawdown_nb`.
Takes into account both recovered and active drawdowns."""
drawdown = nb.dd_drawdown_nb(self.get_field_arr('peak_val'),
self.get_field_arr('valley_val'))
return self.map_array(drawdown)
@cached_method
def avg_drawdown(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Average drawdown (ADD).
Based on `Drawdowns.drawdown`."""
wrap_kwargs = merge_dicts(dict(name_or_index='avg_drawdown'),
wrap_kwargs)
return self.drawdown.mean(group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def max_drawdown(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Maximum drawdown (MDD).
Based on `Drawdowns.drawdown`."""
wrap_kwargs = merge_dicts(dict(name_or_index='max_drawdown'),
wrap_kwargs)
return self.drawdown.min(group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
# ############# Recovery ############# #
@cached_property
def recovery_return(self) -> MappedArray:
"""See `vectorbt.generic.nb.dd_recovery_return_nb`.
Takes into account both recovered and active drawdowns."""
recovery_return = nb.dd_recovery_return_nb(
self.get_field_arr('valley_val'), self.get_field_arr('end_val'))
return self.map_array(recovery_return)
@cached_method
def avg_recovery_return(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Average recovery return.
Based on `Drawdowns.recovery_return`."""
wrap_kwargs = merge_dicts(dict(name_or_index='avg_recovery_return'),
wrap_kwargs)
return self.recovery_return.mean(group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def max_recovery_return(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Maximum recovery return.
Based on `Drawdowns.recovery_return`."""
wrap_kwargs = merge_dicts(dict(name_or_index='max_recovery_return'),
wrap_kwargs)
return self.recovery_return.max(group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
# ############# Duration ############# #
@cached_property
def decline_duration(self) -> MappedArray:
"""See `vectorbt.generic.nb.dd_decline_duration_nb`.
Takes into account both recovered and active drawdowns."""
decline_duration = nb.dd_decline_duration_nb(
self.get_field_arr('start_idx'), self.get_field_arr('valley_idx'))
return self.map_array(decline_duration)
@cached_property
def recovery_duration(self) -> MappedArray:
"""See `vectorbt.generic.nb.dd_recovery_duration_nb`.
A value higher than 1 means the recovery was slower than the decline.
Takes into account both recovered and active drawdowns."""
recovery_duration = nb.dd_recovery_duration_nb(
self.get_field_arr('valley_idx'), self.get_field_arr('end_idx'))
return self.map_array(recovery_duration)
@cached_property
def recovery_duration_ratio(self) -> MappedArray:
"""See `vectorbt.generic.nb.dd_recovery_duration_ratio_nb`.
Takes into account both recovered and active drawdowns."""
recovery_duration_ratio = nb.dd_recovery_duration_ratio_nb(
self.get_field_arr('start_idx'), self.get_field_arr('valley_idx'),
self.get_field_arr('end_idx'))
return self.map_array(recovery_duration_ratio)
# ############# Status: Active ############# #
@cached_method
def active_drawdown(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None) -> tp.MaybeSeries:
"""Drawdown of the last active drawdown only.
Does not support grouping."""
if self.wrapper.grouper.is_grouped(group_by=group_by):
raise ValueError("Grouping is not supported by this method")
wrap_kwargs = merge_dicts(dict(name_or_index='active_drawdown'),
wrap_kwargs)
active = self.active
curr_end_val = active.end_val.nth(-1, group_by=group_by)
curr_peak_val = active.peak_val.nth(-1, group_by=group_by)
curr_drawdown = (curr_end_val - curr_peak_val) / curr_peak_val
return self.wrapper.wrap_reduced(curr_drawdown,
group_by=group_by,
**wrap_kwargs)
@cached_method
def active_duration(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Duration of the last active drawdown only.
Does not support grouping."""
if self.wrapper.grouper.is_grouped(group_by=group_by):
raise ValueError("Grouping is not supported by this method")
wrap_kwargs = merge_dicts(
dict(to_timedelta=True, name_or_index='active_duration'),
wrap_kwargs)
return self.active.duration.nth(-1,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def active_recovery(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None) -> tp.MaybeSeries:
"""Recovery of the last active drawdown only.
Does not support grouping."""
if self.wrapper.grouper.is_grouped(group_by=group_by):
raise ValueError("Grouping is not supported by this method")
wrap_kwargs = merge_dicts(dict(name_or_index='active_recovery'),
wrap_kwargs)
active = self.active
curr_peak_val = active.peak_val.nth(-1, group_by=group_by)
curr_end_val = active.end_val.nth(-1, group_by=group_by)
curr_valley_val = active.valley_val.nth(-1, group_by=group_by)
curr_recovery = (curr_end_val - curr_valley_val) / (curr_peak_val -
curr_valley_val)
return self.wrapper.wrap_reduced(curr_recovery,
group_by=group_by,
**wrap_kwargs)
@cached_method
def active_recovery_return(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Recovery return of the last active drawdown only.
Does not support grouping."""
if self.wrapper.grouper.is_grouped(group_by=group_by):
raise ValueError("Grouping is not supported by this method")
wrap_kwargs = merge_dicts(dict(name_or_index='active_recovery_return'),
wrap_kwargs)
return self.active.recovery_return.nth(-1,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
@cached_method
def active_recovery_duration(self,
group_by: tp.GroupByLike = None,
wrap_kwargs: tp.KwargsLike = None,
**kwargs) -> tp.MaybeSeries:
"""Recovery duration of the last active drawdown only.
Does not support grouping."""
if self.wrapper.grouper.is_grouped(group_by=group_by):
raise ValueError("Grouping is not supported by this method")
wrap_kwargs = merge_dicts(
dict(to_timedelta=True, name_or_index='active_recovery_duration'),
wrap_kwargs)
return self.active.recovery_duration.nth(-1,
group_by=group_by,
wrap_kwargs=wrap_kwargs,
**kwargs)
# ############# Stats ############# #
@property
def stats_defaults(self) -> tp.Kwargs:
"""Defaults for `Drawdowns.stats`.
Merges `vectorbt.generic.ranges.Ranges.stats_defaults` and
`drawdowns.stats` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
drawdowns_stats_cfg = settings['drawdowns']['stats']
return merge_dicts(Ranges.stats_defaults.__get__(self),
drawdowns_stats_cfg)
_metrics: tp.ClassVar[Config] = Config(dict(
start=dict(title='Start',
calc_func=lambda self: self.wrapper.index[0],
agg_func=None,
tags='wrapper'),
end=dict(title='End',
calc_func=lambda self: self.wrapper.index[-1],
agg_func=None,
tags='wrapper'),
period=dict(title='Period',
calc_func=lambda self: len(self.wrapper.index),
apply_to_timedelta=True,
agg_func=None,
tags='wrapper'),
coverage=dict(title='Coverage [%]',
calc_func='coverage',
post_calc_func=lambda self, out, settings: out * 100,
tags=['ranges', 'duration']),
total_records=dict(title='Total Records',
calc_func='count',
tags='records'),
total_recovered=dict(title='Total Recovered Drawdowns',
calc_func='recovered.count',
tags='drawdowns'),
total_active=dict(title='Total Active Drawdowns',
calc_func='active.count',
tags='drawdowns'),
active_dd=dict(title='Active Drawdown [%]',
calc_func='active_drawdown',
post_calc_func=lambda self, out, settings: -out * 100,
check_is_not_grouped=True,
tags=['drawdowns', 'active']),
active_duration=dict(title='Active Duration',
calc_func='active_duration',
fill_wrap_kwargs=True,
check_is_not_grouped=True,
tags=['drawdowns', 'active', 'duration']),
active_recovery=dict(
title='Active Recovery [%]',
calc_func='active_recovery',
post_calc_func=lambda self, out, settings: out * 100,
check_is_not_grouped=True,
tags=['drawdowns', 'active']),
active_recovery_return=dict(
title='Active Recovery Return [%]',
calc_func='active_recovery_return',
post_calc_func=lambda self, out, settings: out * 100,
check_is_not_grouped=True,
tags=['drawdowns', 'active']),
active_recovery_duration=dict(title='Active Recovery Duration',
calc_func='active_recovery_duration',
fill_wrap_kwargs=True,
check_is_not_grouped=True,
tags=['drawdowns', 'active',
'duration']),
max_dd=dict(
title='Max Drawdown [%]',
calc_func=RepEval(
"'max_drawdown' if incl_active else 'recovered.max_drawdown'"),
post_calc_func=lambda self, out, settings: -out * 100,
tags=RepEval(
"['drawdowns'] if incl_active else ['drawdowns', 'recovered']")
),
avg_dd=dict(
title='Avg Drawdown [%]',
calc_func=RepEval(
"'avg_drawdown' if incl_active else 'recovered.avg_drawdown'"),
post_calc_func=lambda self, out, settings: -out * 100,
tags=RepEval(
"['drawdowns'] if incl_active else ['drawdowns', 'recovered']")
),
max_dd_duration=dict(
title='Max Drawdown Duration',
calc_func=RepEval(
"'max_duration' if incl_active else 'recovered.max_duration'"),
fill_wrap_kwargs=True,
tags=RepEval(
"['drawdowns', 'duration'] if incl_active else ['drawdowns', 'recovered', 'duration']"
)),
avg_dd_duration=dict(
title='Avg Drawdown Duration',
calc_func=RepEval(
"'avg_duration' if incl_active else 'recovered.avg_duration'"),
fill_wrap_kwargs=True,
tags=RepEval(
"['drawdowns', 'duration'] if incl_active else ['drawdowns', 'recovered', 'duration']"
)),
max_return=dict(title='Max Recovery Return [%]',
calc_func='recovered.recovery_return.max',
post_calc_func=lambda self, out, settings: out * 100,
tags=['drawdowns', 'recovered']),
avg_return=dict(title='Avg Recovery Return [%]',
calc_func='recovered.recovery_return.mean',
post_calc_func=lambda self, out, settings: out * 100,
tags=['drawdowns', 'recovered']),
max_recovery_duration=dict(title='Max Recovery Duration',
calc_func='recovered.recovery_duration.max',
apply_to_timedelta=True,
tags=['drawdowns', 'recovered',
'duration']),
avg_recovery_duration=dict(
title='Avg Recovery Duration',
calc_func='recovered.recovery_duration.mean',
apply_to_timedelta=True,
tags=['drawdowns', 'recovered', 'duration']),
recovery_duration_ratio=dict(
title='Avg Recovery Duration Ratio',
calc_func='recovered.recovery_duration_ratio.mean',
tags=['drawdowns', 'recovered'])),
copy_kwargs=dict(copy_mode='deep'))
@property
def metrics(self) -> Config:
return self._metrics
# ############# Plotting ############# #
def plot(self,
column: tp.Optional[tp.Label] = None,
top_n: int = 5,
plot_zones: bool = True,
ts_trace_kwargs: tp.KwargsLike = None,
peak_trace_kwargs: tp.KwargsLike = None,
valley_trace_kwargs: tp.KwargsLike = None,
recovery_trace_kwargs: tp.KwargsLike = None,
active_trace_kwargs: tp.KwargsLike = None,
decline_shape_kwargs: tp.KwargsLike = None,
recovery_shape_kwargs: tp.KwargsLike = None,
active_shape_kwargs: tp.KwargsLike = None,
add_trace_kwargs: tp.KwargsLike = None,
xref: str = 'x',
yref: str = 'y',
fig: tp.Optional[tp.BaseFigure] = None,
**layout_kwargs) -> tp.BaseFigure: # pragma: no cover
"""Plot drawdowns.
Args:
column (str): Name of the column to plot.
top_n (int): Filter top N drawdown records by maximum drawdown.
plot_zones (bool): Whether to plot zones.
ts_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for `Drawdowns.ts`.
peak_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for peak values.
valley_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for valley values.
recovery_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for recovery values.
active_trace_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Scatter` for active recovery values.
decline_shape_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Figure.add_shape` for decline zones.
recovery_shape_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Figure.add_shape` for recovery zones.
active_shape_kwargs (dict): Keyword arguments passed to `plotly.graph_objects.Figure.add_shape` for active recovery zones.
add_trace_kwargs (dict): Keyword arguments passed to `add_trace`.
xref (str): X coordinate axis.
yref (str): Y coordinate axis.
fig (Figure or FigureWidget): Figure to add traces to.
**layout_kwargs: Keyword arguments for layout.
## Example
```python-repl
>>> import vectorbt as vbt
>>> from datetime import datetime, timedelta
>>> import pandas as pd
>>> price = pd.Series([1, 2, 1, 2, 3, 2, 1, 2], name='Price')
>>> price.index = [datetime(2020, 1, 1) + timedelta(days=i) for i in range(len(price))]
>>> vbt.Drawdowns.from_ts(price, wrapper_kwargs=dict(freq='1 day')).plot()
```
"""
from vectorbt._settings import settings
plotting_cfg = settings['plotting']
self_col = self.select_one(column=column, group_by=False)
if top_n is not None:
# Drawdowns is negative, thus top_n becomes bottom_n
self_col = self_col.apply_mask(
self_col.drawdown.bottom_n_mask(top_n))
if ts_trace_kwargs is None:
ts_trace_kwargs = {}
ts_trace_kwargs = merge_dicts(
dict(line=dict(color=plotting_cfg['color_schema']['blue'])),
ts_trace_kwargs)
if peak_trace_kwargs is None:
peak_trace_kwargs = {}
if valley_trace_kwargs is None:
valley_trace_kwargs = {}
if recovery_trace_kwargs is None:
recovery_trace_kwargs = {}
if active_trace_kwargs is None:
active_trace_kwargs = {}
if decline_shape_kwargs is None:
decline_shape_kwargs = {}
if recovery_shape_kwargs is None:
recovery_shape_kwargs = {}
if active_shape_kwargs is None:
active_shape_kwargs = {}
if add_trace_kwargs is None:
add_trace_kwargs = {}
if fig is None:
fig = make_figure()
fig.update_layout(**layout_kwargs)
y_domain = get_domain(yref, fig)
if self_col.ts is not None:
fig = self_col.ts.vbt.plot(trace_kwargs=ts_trace_kwargs,
add_trace_kwargs=add_trace_kwargs,
fig=fig)
if self_col.count() > 0:
# Extract information
id_ = self_col.get_field_arr('id')
id_title = self_col.get_field_title('id')
peak_idx = self_col.get_map_field_to_index('peak_idx')
peak_idx_title = self_col.get_field_title('peak_idx')
if self_col.ts is not None:
peak_val = self_col.ts.loc[peak_idx]
else:
peak_val = self_col.get_field_arr('peak_val')
peak_val_title = self_col.get_field_title('peak_val')
valley_idx = self_col.get_map_field_to_index('valley_idx')
valley_idx_title = self_col.get_field_title('valley_idx')
if self_col.ts is not None:
valley_val = self_col.ts.loc[valley_idx]
else:
valley_val = self_col.get_field_arr('valley_val')
valley_val_title = self_col.get_field_title('valley_val')
end_idx = self_col.get_map_field_to_index('end_idx')
end_idx_title = self_col.get_field_title('end_idx')
if self_col.ts is not None:
end_val = self_col.ts.loc[end_idx]
else:
end_val = self_col.get_field_arr('end_val')
end_val_title = self_col.get_field_title('end_val')
drawdown = self_col.drawdown.values
recovery_return = self_col.recovery_return.values
decline_duration = np.vectorize(str)(self_col.wrapper.to_timedelta(
self_col.decline_duration.values,
to_pd=True,
silence_warnings=True))
recovery_duration = np.vectorize(str)(
self_col.wrapper.to_timedelta(
self_col.recovery_duration.values,
to_pd=True,
silence_warnings=True))
duration = np.vectorize(str)(self_col.wrapper.to_timedelta(
self_col.duration.values, to_pd=True, silence_warnings=True))
status = self_col.get_field_arr('status')
peak_mask = peak_idx != np.roll(
end_idx, 1) # peak and recovery at same time -> recovery wins
if peak_mask.any():
# Plot peak markers
peak_customdata = id_[peak_mask][:, None]
peak_scatter = go.Scatter(
x=peak_idx[peak_mask],
y=peak_val[peak_mask],
mode='markers',
marker=dict(
symbol='diamond',
color=plotting_cfg['contrast_color_schema']['blue'],
size=7,
line=dict(width=1,
color=adjust_lightness(
plotting_cfg['contrast_color_schema']
['blue']))),
name='Peak',
customdata=peak_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{peak_idx_title}: %{{x}}"
f"<br>{peak_val_title}: %{{y}}")
peak_scatter.update(**peak_trace_kwargs)
fig.add_trace(peak_scatter, **add_trace_kwargs)
recovered_mask = status == DrawdownStatus.Recovered
if recovered_mask.any():
# Plot valley markers
valley_customdata = np.stack(
(id_[recovered_mask], drawdown[recovered_mask],
decline_duration[recovered_mask]),
axis=1)
valley_scatter = go.Scatter(
x=valley_idx[recovered_mask],
y=valley_val[recovered_mask],
mode='markers',
marker=dict(
symbol='diamond',
color=plotting_cfg['contrast_color_schema']['red'],
size=7,
line=dict(width=1,
color=adjust_lightness(
plotting_cfg['contrast_color_schema']
['red']))),
name='Valley',
customdata=valley_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{valley_idx_title}: %{{x}}"
f"<br>{valley_val_title}: %{{y}}"
f"<br>Drawdown: %{{customdata[1]:.2%}}"
f"<br>Duration: %{{customdata[2]}}")
valley_scatter.update(**valley_trace_kwargs)
fig.add_trace(valley_scatter, **add_trace_kwargs)
if plot_zones:
# Plot drawdown zones
for i in range(len(id_[recovered_mask])):
fig.add_shape(**merge_dicts(
dict(
type="rect",
xref=xref,
yref="paper",
x0=peak_idx[recovered_mask][i],
y0=y_domain[0],
x1=valley_idx[recovered_mask][i],
y1=y_domain[1],
fillcolor='red',
opacity=0.2,
layer="below",
line_width=0,
), decline_shape_kwargs))
# Plot recovery markers
recovery_customdata = np.stack(
(id_[recovered_mask], recovery_return[recovered_mask],
recovery_duration[recovered_mask]),
axis=1)
recovery_scatter = go.Scatter(
x=end_idx[recovered_mask],
y=end_val[recovered_mask],
mode='markers',
marker=dict(
symbol='diamond',
color=plotting_cfg['contrast_color_schema']['green'],
size=7,
line=dict(width=1,
color=adjust_lightness(
plotting_cfg['contrast_color_schema']
['green']))),
name='Recovery/Peak',
customdata=recovery_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{end_idx_title}: %{{x}}"
f"<br>{end_val_title}: %{{y}}"
f"<br>Return: %{{customdata[1]:.2%}}"
f"<br>Duration: %{{customdata[2]}}")
recovery_scatter.update(**recovery_trace_kwargs)
fig.add_trace(recovery_scatter, **add_trace_kwargs)
if plot_zones:
# Plot recovery zones
for i in range(len(id_[recovered_mask])):
fig.add_shape(**merge_dicts(
dict(
type="rect",
xref=xref,
yref="paper",
x0=valley_idx[recovered_mask][i],
y0=y_domain[0],
x1=end_idx[recovered_mask][i],
y1=y_domain[1],
fillcolor='green',
opacity=0.2,
layer="below",
line_width=0,
), recovery_shape_kwargs))
# Plot active markers
active_mask = status == DrawdownStatus.Active
if active_mask.any():
active_customdata = np.stack(
(id_[active_mask], drawdown[active_mask],
duration[active_mask]),
axis=1)
active_scatter = go.Scatter(
x=end_idx[active_mask],
y=end_val[active_mask],
mode='markers',
marker=dict(
symbol='diamond',
color=plotting_cfg['contrast_color_schema']['orange'],
size=7,
line=dict(width=1,
color=adjust_lightness(
plotting_cfg['contrast_color_schema']
['orange']))),
name='Active',
customdata=active_customdata,
hovertemplate=f"{id_title}: %{{customdata[0]}}"
f"<br>{end_idx_title}: %{{x}}"
f"<br>{end_val_title}: %{{y}}"
f"<br>Return: %{{customdata[1]:.2%}}"
f"<br>Duration: %{{customdata[2]}}")
active_scatter.update(**active_trace_kwargs)
fig.add_trace(active_scatter, **add_trace_kwargs)
if plot_zones:
# Plot active drawdown zones
for i in range(len(id_[active_mask])):
fig.add_shape(**merge_dicts(
dict(
type="rect",
xref=xref,
yref="paper",
x0=peak_idx[active_mask][i],
y0=y_domain[0],
x1=end_idx[active_mask][i],
y1=y_domain[1],
fillcolor='orange',
opacity=0.2,
layer="below",
line_width=0,
), active_shape_kwargs))
return fig
@property
def plots_defaults(self) -> tp.Kwargs:
"""Defaults for `Drawdowns.plots`.
Merges `vectorbt.generic.ranges.Ranges.plots_defaults` and
`drawdowns.plots` from `vectorbt._settings.settings`."""
from vectorbt._settings import settings
drawdowns_plots_cfg = settings['drawdowns']['plots']
return merge_dicts(Ranges.plots_defaults.__get__(self),
drawdowns_plots_cfg)
_subplots: tp.ClassVar[Config] = Config(
dict(plot=dict(title="Drawdowns",
check_is_not_grouped=True,
plot_func='plot',
tags='drawdowns')),
copy_kwargs=dict(copy_mode='deep'))
@property
def subplots(self) -> Config:
return self._subplots
import numpy as np
import json
from vectorbt.utils.config import Config
__pdoc__ = {}
# Color schema
color_schema = Config(
blue="#1f77b4",
orange="#ff7f0e",
green="#2ca02c",
red="#dc3912",
purple="#9467bd",
brown="#8c564b",
pink="#e377c2",
gray="#7f7f7f",
yellow="#bcbd22",
cyan="#17becf",
increasing="#1b9e76",
decreasing="#d95f02"
)
"""_"""
__pdoc__['color_schema'] = f"""Color schema.
```plaintext
{json.dumps(color_schema, indent=2, default=str)}
```
"""