Skip to content

accessors module

Custom Pandas accessors for returns.

Methods can be accessed as follows:

Note

The underlying Series/DataFrame must already be a return series. To convert price to returns, use ReturnsAccessor.from_value().

Grouping is only supported by the methods that accept the group_by argument.

Accessors do not utilize caching.

There are three options to compute returns and get the accessor:

>>> from vectorbtpro import *

>>> price = pd.Series([1.1, 1.2, 1.3, 1.2, 1.1])

>>> # 1. pd.Series.pct_change
>>> rets = price.pct_change()
>>> ret_acc = rets.vbt.returns(freq='d')

>>> # 2. vectorbtpro.generic.accessors.GenericAccessor.to_returns
>>> rets = price.vbt.to_returns()
>>> ret_acc = rets.vbt.returns(freq='d')

>>> # 3. vectorbtpro.returns.accessors.ReturnsAccessor.from_value
>>> ret_acc = pd.Series.vbt.returns.from_value(price, freq='d')

>>> # vectorbtpro.returns.accessors.ReturnsAccessor.total
>>> ret_acc.total()
0.0

The accessors extend vectorbtpro.generic.accessors.

>>> # inherited from GenericAccessor
>>> ret_acc.max()
0.09090909090909083

Defaults

ReturnsAccessor accepts defaults dictionary where you can pass defaults for arguments used throughout the accessor, such as

  • start_value: The starting value.
  • window: Window length.
  • minp: Minimum number of observations in a window required to have a value.
  • ddof: Delta Degrees of Freedom.
  • risk_free: Constant risk-free return throughout the period.
  • levy_alpha: Scaling relation (Levy stability exponent).
  • required_return: Minimum acceptance return of the investor.
  • cutoff: Decimal representing the percentage cutoff for the bottom percentile of returns.
  • period: Number of observations for annualization. Can be an integer or "dt_period".

Defaults as well as bm_returns and year_freq can be set globally using settings:

>>> benchmark = pd.Series([1.05, 1.1, 1.15, 1.1, 1.05])
>>> bm_returns = benchmark.vbt.to_returns()

>>> vbt.settings.returns['bm_returns'] = bm_returns

Stats

Hint

See StatsBuilderMixin.stats() and ReturnsAccessor.metrics.

>>> ret_acc.stats()
Start                                      0
End                                        4
Duration                     5 days 00:00:00
Total Return [%]                           0
Benchmark Return [%]                       0
Annualized Return [%]                      0
Annualized Volatility [%]            184.643
Sharpe Ratio                        0.691185
Calmar Ratio                               0
Max Drawdown [%]                     15.3846
Omega Ratio                          1.08727
Sortino Ratio                        1.17805
Skew                              0.00151002
Kurtosis                            -5.94737
Tail Ratio                           1.08985
Common Sense Ratio                   1.08985
Value at Risk                     -0.0823718
Alpha                                0.78789
Beta                                 1.83864
dtype: object

Note

StatsBuilderMixin.stats() does not support grouping.

Plots

Hint

See PlotsBuilderMixin.plots() and ReturnsAccessor.subplots.

ReturnsAccessor class has a single subplot based on ReturnsAccessor.plot_cumulative():

>>> ret_acc.plots().show()

ReturnsAccessor class

ReturnsAccessor(
    wrapper,
    obj=None,
    bm_returns=None,
    log_returns=False,
    year_freq=None,
    defaults=None,
    sim_start=None,
    sim_end=None,
    **kwargs
)

Accessor on top of return series. For both, Series and DataFrames.

Accessible via pd.Series.vbt.returns and pd.DataFrame.vbt.returns.

Args

obj : pd.Series or pd.DataFrame
Pandas object representing returns.
bm_returns : array_like
Pandas object representing benchmark returns.
log_returns : bool
Whether returns and benchmark returns are provided as log returns.
year_freq : any
Year frequency for annualization purposes.
defaults : dict
Defaults that override defaults in returns.
sim_start : int, datetime_like, or array_like
Simulation start per column.
sim_end : int, datetime_like, or array_like
Simulation end per column.
**kwargs
Keyword arguments that are passed down to GenericAccessor.

Superclasses

Inherited members

Subclasses

alpha method

ReturnsAccessor.alpha(
    bm_returns=None,
    risk_free=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Alpha.

See alpha_nb().

ann_factor property

Annualization factor.

ann_factor_to_year_freq class method

ReturnsAccessor.ann_factor_to_year_freq(
    ann_factor,
    freq,
    method_name=None
)

Convert annualization factor into year frequency.

annual method

ReturnsAccessor.annual(
    jitted=None,
    chunked=None,
    **kwargs
)

Annual returns.

annualized method

ReturnsAccessor.annualized(
    period=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Annualized return.

See annualized_return_nb().

annualized_volatility method

ReturnsAccessor.annualized_volatility(
    levy_alpha=None,
    ddof=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Annualized volatility.

See annualized_volatility_nb().

auto_detect_ann_factor class method

ReturnsAccessor.auto_detect_ann_factor(
    index
)

Auto-detect annualization factor from a datetime index.

beta method

ReturnsAccessor.beta(
    bm_returns=None,
    ddof=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Beta.

See beta_nb().

bm_returns property

Benchmark returns.

bm_returns_acc property

ReturnsAccessor.get_bm_returns_acc() with default arguments.

calmar_ratio method

ReturnsAccessor.calmar_ratio(
    period=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Calmar ratio.

See calmar_ratio_nb().

capture_ratio method

ReturnsAccessor.capture_ratio(
    bm_returns=None,
    period=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Capture ratio.

See capture_ratio_nb().

common_sense_ratio method

ReturnsAccessor.common_sense_ratio(
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Common Sense Ratio (CSR).

See common_sense_ratio_nb().

cond_value_at_risk method

ReturnsAccessor.cond_value_at_risk(
    cutoff=None,
    sim_start=None,
    sim_end=None,
    noarr_mode=True,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Conditional Value at Risk (CVaR).

See cond_value_at_risk_nb().

cumulative method

ReturnsAccessor.cumulative(
    start_value=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Cumulative returns.

See cumulative_returns_nb().

daily method

ReturnsAccessor.daily(
    jitted=None,
    chunked=None,
    **kwargs
)

Daily returns.

deannualize method

ReturnsAccessor.deannualize(
    value
)

Deannualize a value.

defaults property

Defaults for ReturnsAccessor.

Merges defaults from returns with defaults from ReturnsAccessor.

deflated_sharpe_ratio method

ReturnsAccessor.deflated_sharpe_ratio(
    risk_free=None,
    ddof=None,
    bias=True,
    wrap_kwargs=None
)

Deflated Sharpe Ratio (DSR).

Expresses the chance that the advertised strategy has a positive Sharpe ratio.

down_capture_ratio method

ReturnsAccessor.down_capture_ratio(
    bm_returns=None,
    period=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Up-market capture ratio.

See down_capture_ratio_nb().

downside_risk method

ReturnsAccessor.downside_risk(
    required_return=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Downside risk.

See downside_risk_nb().

drawdown method

ReturnsAccessor.drawdown(
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Relative decline from a peak.

drawdowns property

ReturnsAccessor.get_drawdowns() with default arguments.

final_value method

ReturnsAccessor.final_value(
    start_value=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Final value.

See final_value_nb().

from_value class method

ReturnsAccessor.from_value(
    value,
    init_value=nan,
    log_returns=False,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrapper=None,
    wrapper_kwargs=None,
    return_values=False,
    **kwargs
)

Returns a new ReturnsAccessor instance with returns calculated from value.

get_ann_factor class method

ReturnsAccessor.get_ann_factor(
    year_freq=None,
    freq=None,
    raise_error=False
)

Get the annualization factor from the year and data frequency.

get_bm_returns_acc method

ReturnsAccessor.get_bm_returns_acc(
    bm_returns=None,
    sim_start=None,
    sim_end=None
)

Get accessor for benchmark returns.

get_drawdowns method

ReturnsAccessor.get_drawdowns(
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    **kwargs
)

Generate drawdown records of cumulative returns.

See Drawdowns.

get_period class method

ReturnsAccessor.get_period(
    period=None,
    sim_start=None,
    sim_end=None,
    wrapper=None,
    group_by=None
)

Prepare period.

get_year_freq class method

ReturnsAccessor.get_year_freq(
    year_freq=None,
    index=None,
    freq=None
)

Resolve year frequency.

If year_freq is "auto", uses ReturnsAccessor.auto_detect_ann_factor(). If year_freq is "auto_[method_name], also applies the methodnp.[method_name]to the annualization factor, mostly to round it. Ifyear_freqis "index_[method_name]", uses [ReturnsAccessor.parse_ann_factor()](https://vectorbt.pro/pvt_12537e02/api/returns/accessors/#vectorbtpro.returns.accessors.ReturnsAccessor.parse_ann_factor "vectorbtpro.returns.accessors.ReturnsAccessor.parse_ann_factor") to determine the annualization factor by applying the method topd.DatetimeIndex.year`.

indexing_func method

ReturnsAccessor.indexing_func(
    *args,
    wrapper_meta=None,
    **kwargs
)

Perform indexing on ReturnsAccessor.

information_ratio method

ReturnsAccessor.information_ratio(
    bm_returns=None,
    ddof=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Information ratio.

See information_ratio_nb().

log_returns property

Whether returns and benchmark returns are provided as log returns.

max_drawdown method

ReturnsAccessor.max_drawdown(
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Maximum Drawdown (MDD).

See max_drawdown_nb().

Yields the same out as max_drawdown of ReturnsAccessor.drawdowns.

metrics class variable

Metrics supported by ReturnsAccessor.

HybridConfig(
    start_index=dict(
        title='Start Index',
        calc_func='sim_start_index',
        tags='wrapper'
    ),
    end_index=dict(
        title='End Index',
        calc_func='sim_end_index',
        tags='wrapper'
    ),
    total_duration=dict(
        title='Total Duration',
        calc_func='sim_duration',
        apply_to_timedelta=True,
        tags='wrapper'
    ),
    total_return=dict(
        title='Total Return [%]',
        calc_func='total',
        post_calc_func=<function ReturnsAccessor.<lambda> at 0x15f5a93a0>,
        tags='returns'
    ),
    bm_return=dict(
        title='Benchmark Return [%]',
        calc_func='bm_returns_acc.total',
        post_calc_func=<function ReturnsAccessor.<lambda> at 0x15f5a9440>,
        check_has_bm_returns=True,
        tags='returns'
    ),
    ann_return=dict(
        title='Annualized Return [%]',
        calc_func='annualized',
        post_calc_func=<function ReturnsAccessor.<lambda> at 0x15f5a94e0>,
        check_has_freq=True,
        check_has_year_freq=True,
        tags='returns'
    ),
    ann_volatility=dict(
        title='Annualized Volatility [%]',
        calc_func='annualized_volatility',
        post_calc_func=<function ReturnsAccessor.<lambda> at 0x15f5a9580>,
        check_has_freq=True,
        check_has_year_freq=True,
        tags='returns'
    ),
    max_dd=dict(
        title='Max Drawdown [%]',
        calc_func='drawdowns.get_max_drawdown',
        post_calc_func=<function ReturnsAccessor.<lambda> at 0x15f5a9620>,
        tags=[
            'returns',
            'drawdowns'
        ]
    ),
    max_dd_duration=dict(
        title='Max Drawdown Duration',
        calc_func='drawdowns.get_max_duration',
        fill_wrap_kwargs=True,
        tags=[
            'returns',
            'drawdowns',
            'duration'
        ]
    ),
    sharpe_ratio=dict(
        title='Sharpe Ratio',
        calc_func='sharpe_ratio',
        check_has_freq=True,
        check_has_year_freq=True,
        tags='returns'
    ),
    calmar_ratio=dict(
        title='Calmar Ratio',
        calc_func='calmar_ratio',
        check_has_freq=True,
        check_has_year_freq=True,
        tags='returns'
    ),
    omega_ratio=dict(
        title='Omega Ratio',
        calc_func='omega_ratio',
        check_has_freq=True,
        check_has_year_freq=True,
        tags='returns'
    ),
    sortino_ratio=dict(
        title='Sortino Ratio',
        calc_func='sortino_ratio',
        check_has_freq=True,
        check_has_year_freq=True,
        tags='returns'
    ),
    skew=dict(
        title='Skew',
        calc_func='obj.skew',
        tags='returns'
    ),
    kurtosis=dict(
        title='Kurtosis',
        calc_func='obj.kurtosis',
        tags='returns'
    ),
    tail_ratio=dict(
        title='Tail Ratio',
        calc_func='tail_ratio',
        tags='returns'
    ),
    common_sense_ratio=dict(
        title='Common Sense Ratio',
        calc_func='common_sense_ratio',
        check_has_freq=True,
        check_has_year_freq=True,
        tags='returns'
    ),
    value_at_risk=dict(
        title='Value at Risk',
        calc_func='value_at_risk',
        tags='returns'
    ),
    alpha=dict(
        title='Alpha',
        calc_func='alpha',
        check_has_freq=True,
        check_has_year_freq=True,
        check_has_bm_returns=True,
        tags='returns'
    ),
    beta=dict(
        title='Beta',
        calc_func='beta',
        check_has_bm_returns=True,
        tags='returns'
    )
)

Returns ReturnsAccessor._metrics, which gets (hybrid-) 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 ReturnsAccessor._metrics.

omega_ratio method

ReturnsAccessor.omega_ratio(
    risk_free=None,
    required_return=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Omega ratio.

See omega_ratio_nb().

parse_ann_factor class method

ReturnsAccessor.parse_ann_factor(
    index,
    method_name='max'
)

Parse annualization factor from a datetime index.

period property

Period.

plot_cumulative method

ReturnsAccessor.plot_cumulative(
    column=None,
    bm_returns=None,
    start_value=1,
    sim_start=None,
    sim_end=None,
    fit_sim_range=True,
    fill_to_benchmark=False,
    main_kwargs=None,
    bm_kwargs=None,
    pct_scale=False,
    hline_shape_kwargs=None,
    add_trace_kwargs=None,
    xref='x',
    yref='y',
    fig=None,
    **layout_kwargs
)

Plot cumulative returns.

Args

column : str
Name of the column to plot.
bm_returns : array_like
Benchmark return to compare returns against. Will broadcast per element.
start_value : float
The starting value.
sim_start : int, datetime_like, or array_like
Simulation start row or index (inclusive).
sim_end : int, datetime_like, or array_like
Simulation end row or index (exclusive).
fit_sim_range : bool
Whether to fit figure to simulation range.
fill_to_benchmark : bool
Whether to fill between main and benchmark, or between main and start_value.
main_kwargs : dict
Keyword arguments passed to GenericAccessor.plot() for main.
bm_kwargs : dict
Keyword arguments passed to GenericAccessor.plot() for benchmark.
pct_scale : bool
Whether to use the percentage scale for the y-axis.
hline_shape_kwargs : dict
Keyword arguments passed to plotly.graph_objects.Figure.add_shape for start_value line.
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.

Usage

>>> np.random.seed(0)
>>> rets = pd.Series(np.random.uniform(-0.05, 0.05, size=100))
>>> bm_returns = pd.Series(np.random.uniform(-0.05, 0.05, size=100))
>>> rets.vbt.returns.plot_cumulative(bm_returns=bm_returns).show()

plots_defaults property

Defaults for PlotsBuilderMixin.plots().

Merges GenericAccessor.plots_defaults, defaults from ReturnsAccessor.defaults (acting as settings), and plots from returns

prob_sharpe_ratio method

ReturnsAccessor.prob_sharpe_ratio(
    bm_returns=None,
    risk_free=None,
    ddof=None,
    bias=True,
    wrap_kwargs=None
)

Probabilistic Sharpe Ratio (PSR).

profit_factor method

ReturnsAccessor.profit_factor(
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Profit factor.

See profit_factor_nb().

qs property

Quantstats adapter.

resample method

ReturnsAccessor.resample(
    *args,
    fill_with_zero=True,
    wrapper_meta=None,
    **kwargs
)

Perform resampling on ReturnsAccessor.

resample_returns method

ReturnsAccessor.resample_returns(
    rule,
    jitted=None,
    chunked=None,
    **kwargs
)

Resample returns to a custom frequency, date offset, or index.

resolve_column_stack_kwargs class method

ReturnsAccessor.resolve_column_stack_kwargs(
    *objs,
    reindex_kwargs=None,
    **kwargs
)

Resolve keyword arguments for initializing ReturnsAccessor after stacking along columns.

resolve_row_stack_kwargs class method

ReturnsAccessor.resolve_row_stack_kwargs(
    *objs,
    **kwargs
)

Resolve keyword arguments for initializing ReturnsAccessor after stacking along rows.

resolve_self method

ReturnsAccessor.resolve_self(
    cond_kwargs=None,
    custom_arg_names=None,
    impacts_caching=True,
    silence_warnings=False
)

Resolve self.

See Wrapping.resolve_self().

Creates a copy of this instance year_freq is different in cond_kwargs.

rolling_alpha method

ReturnsAccessor.rolling_alpha(
    window=None,
    *,
    minp=None,
    bm_returns=None,
    risk_free=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling alpha.

See rolling_alpha_nb().

rolling_annualized method

ReturnsAccessor.rolling_annualized(
    window=None,
    *,
    minp=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling annualized return.

See rolling_annualized_return_nb().

rolling_annualized_volatility method

ReturnsAccessor.rolling_annualized_volatility(
    window=None,
    *,
    minp=None,
    levy_alpha=None,
    ddof=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling annualized volatility.

See rolling_annualized_volatility_nb().

rolling_beta method

ReturnsAccessor.rolling_beta(
    window=None,
    *,
    minp=None,
    bm_returns=None,
    ddof=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling beta.

See rolling_beta_nb().

rolling_calmar_ratio method

ReturnsAccessor.rolling_calmar_ratio(
    window=None,
    *,
    minp=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling Calmar ratio.

See rolling_calmar_ratio_nb().

rolling_capture_ratio method

ReturnsAccessor.rolling_capture_ratio(
    window=None,
    *,
    minp=None,
    bm_returns=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling capture ratio.

See rolling_capture_ratio_nb().

rolling_common_sense_ratio method

ReturnsAccessor.rolling_common_sense_ratio(
    window=None,
    *,
    minp=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling Common Sense Ratio (CSR).

See rolling_common_sense_ratio_nb().

rolling_cond_value_at_risk method

ReturnsAccessor.rolling_cond_value_at_risk(
    window=None,
    *,
    minp=None,
    cutoff=None,
    sim_start=None,
    sim_end=None,
    noarr_mode=True,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling Conditional Value at Risk (CVaR).

See rolling_cond_value_at_risk_nb().

rolling_down_capture_ratio method

ReturnsAccessor.rolling_down_capture_ratio(
    window=None,
    *,
    minp=None,
    bm_returns=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling down-market capture ratio.

See rolling_down_capture_ratio_nb().

rolling_downside_risk method

ReturnsAccessor.rolling_downside_risk(
    window=None,
    *,
    minp=None,
    required_return=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling downside risk.

See rolling_downside_risk_nb().

rolling_final_value method

ReturnsAccessor.rolling_final_value(
    window=None,
    *,
    minp=None,
    start_value=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling final value.

See rolling_final_value_nb().

rolling_information_ratio method

ReturnsAccessor.rolling_information_ratio(
    window=None,
    *,
    minp=None,
    bm_returns=None,
    ddof=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling information ratio.

See rolling_information_ratio_nb().

rolling_max_drawdown method

ReturnsAccessor.rolling_max_drawdown(
    window=None,
    *,
    minp=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling Maximum Drawdown (MDD).

See rolling_max_drawdown_nb().

rolling_omega_ratio method

ReturnsAccessor.rolling_omega_ratio(
    window=None,
    *,
    minp=None,
    risk_free=None,
    required_return=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling Omega ratio.

See rolling_omega_ratio_nb().

rolling_profit_factor method

ReturnsAccessor.rolling_profit_factor(
    window=None,
    *,
    minp=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling profit factor.

See rolling_profit_factor_nb().

rolling_sharpe_ratio method

ReturnsAccessor.rolling_sharpe_ratio(
    window=None,
    *,
    minp=None,
    annualized=True,
    risk_free=None,
    ddof=None,
    sim_start=None,
    sim_end=None,
    stream_mode=True,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling Sharpe ratio.

See rolling_sharpe_ratio_nb().

rolling_sortino_ratio method

ReturnsAccessor.rolling_sortino_ratio(
    window=None,
    *,
    minp=None,
    required_return=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling Sortino ratio.

See rolling_sortino_ratio_nb().

rolling_tail_ratio method

ReturnsAccessor.rolling_tail_ratio(
    window=None,
    *,
    minp=None,
    sim_start=None,
    sim_end=None,
    noarr_mode=True,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling tail ratio.

See rolling_tail_ratio_nb().

rolling_total method

ReturnsAccessor.rolling_total(
    window=None,
    *,
    minp=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling total return.

See rolling_total_return_nb().

rolling_up_capture_ratio method

ReturnsAccessor.rolling_up_capture_ratio(
    window=None,
    *,
    minp=None,
    bm_returns=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling up-market capture ratio.

See rolling_up_capture_ratio_nb().

rolling_value_at_risk method

ReturnsAccessor.rolling_value_at_risk(
    window=None,
    *,
    minp=None,
    cutoff=None,
    sim_start=None,
    sim_end=None,
    noarr_mode=True,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Rolling Value at Risk (VaR).

See rolling_value_at_risk_nb().

sharpe_ratio method

ReturnsAccessor.sharpe_ratio(
    annualized=True,
    risk_free=None,
    ddof=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Sharpe ratio.

See sharpe_ratio_nb().

sharpe_ratio_std method

ReturnsAccessor.sharpe_ratio_std(
    risk_free=None,
    ddof=None,
    bias=True,
    wrap_kwargs=None
)

Standard deviation of the sharpe ratio estimation.

sortino_ratio method

ReturnsAccessor.sortino_ratio(
    required_return=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Sortino ratio.

See sortino_ratio_nb().

stats_defaults property

Defaults for StatsBuilderMixin.stats().

Merges GenericAccessor.stats_defaults, defaults from ReturnsAccessor.defaults (acting as settings), and stats from returns

subplots class variable

Subplots supported by ReturnsAccessor.

HybridConfig(
    plot_cumulative=dict(
        title='Cumulative Returns',
        yaxis_kwargs=dict(
            title='Cumulative returns'
        ),
        plot_func='plot_cumulative',
        pass_hline_shape_kwargs=True,
        pass_add_trace_kwargs=True,
        pass_xref=True,
        pass_yref=True,
        tags='returns'
    )
)

Returns ReturnsAccessor._subplots, which gets (hybrid-) 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 ReturnsAccessor._subplots.

tail_ratio method

ReturnsAccessor.tail_ratio(
    sim_start=None,
    sim_end=None,
    noarr_mode=True,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Tail ratio.

See tail_ratio_nb().

total method

ReturnsAccessor.total(
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Total return.

See total_return_nb().

up_capture_ratio method

ReturnsAccessor.up_capture_ratio(
    bm_returns=None,
    period=None,
    sim_start=None,
    sim_end=None,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Up-market capture ratio.

See up_capture_ratio_nb().

value_at_risk method

ReturnsAccessor.value_at_risk(
    cutoff=None,
    sim_start=None,
    sim_end=None,
    noarr_mode=True,
    jitted=None,
    chunked=None,
    wrap_kwargs=None
)

Value at Risk (VaR).

See value_at_risk_nb().

year_freq property

Year frequency.

year_freq_depends_on_index class method

ReturnsAccessor.year_freq_depends_on_index(
    year_freq
)

Return whether frequency depends on index.

ReturnsDFAccessor class

ReturnsDFAccessor(
    wrapper,
    obj=None,
    bm_returns=None,
    year_freq=None,
    defaults=None,
    sim_start=None,
    sim_end=None,
    **kwargs
)

Accessor on top of return series. For DataFrames only.

Accessible via pd.DataFrame.vbt.returns.

Superclasses

Inherited members

ReturnsSRAccessor class

ReturnsSRAccessor(
    wrapper,
    obj=None,
    bm_returns=None,
    year_freq=None,
    defaults=None,
    sim_start=None,
    sim_end=None,
    **kwargs
)

Accessor on top of return series. For Series only.

Accessible via pd.Series.vbt.returns.

Superclasses

Inherited members