base module¶

Base class for simulating a portfolio and measuring its performance.

returns_acc_config ReadonlyConfig¶

Config of returns accessor methods to be attached to Portfolio.

ReadonlyConfig(
    daily_returns=dict(
        source_name='daily'
    ),
    annual_returns=dict(
        source_name='annual'
    ),
    cumulative_returns=dict(
        source_name='cumulative'
    ),
    annualized_return=dict(
        source_name='annualized'
    ),
    annualized_volatility=dict(),
    calmar_ratio=dict(),
    omega_ratio=dict(),
    sharpe_ratio=dict(),
    sharpe_ratio_std=dict(),
    prob_sharpe_ratio=dict(),
    deflated_sharpe_ratio=dict(),
    downside_risk=dict(),
    sortino_ratio=dict(),
    information_ratio=dict(),
    beta=dict(),
    alpha=dict(),
    tail_ratio=dict(),
    value_at_risk=dict(),
    cond_value_at_risk=dict(),
    capture_ratio=dict(),
    up_capture_ratio=dict(),
    down_capture_ratio=dict(),
    drawdown=dict(),
    max_drawdown=dict()
)

shortcut_config ReadonlyConfig¶

Config of shortcut properties to be attached to Portfolio.

ReadonlyConfig(
    filled_close=dict(
        group_by_aware=False,
        decorator=<class 'vectorbtpro.utils.decorators.cached_property'>
    ),
    filled_bm_close=dict(
        group_by_aware=False,
        decorator=<class 'vectorbtpro.utils.decorators.cached_property'>
    ),
    weights=dict(
        group_by_aware=False,
        decorator=<class 'vectorbtpro.utils.decorators.cached_property'>,
        obj_type='red_array'
    ),
    long_view=dict(
        obj_type='portfolio'
    ),
    short_view=dict(
        obj_type='portfolio'
    ),
    orders=dict(
        obj_type='records',
        field_aliases=(
            'order_records'
        ),
        wrap_func=<function <lambda> at 0x1648a4fe0>,
        indexing_func=functools.partial(<function records_indexing_func at 0x164888b80>, cls='orders_cls'),
        resample_func=functools.partial(<function records_resample_func at 0x164888c20>, cls='orders_cls')
    ),
    logs=dict(
        obj_type='records',
        field_aliases=(
            'log_records'
        ),
        wrap_func=<function <lambda> at 0x1648a5080>,
        indexing_func=functools.partial(<function records_indexing_func at 0x164888b80>, cls='logs_cls'),
        resample_func=functools.partial(<function records_resample_func at 0x164888c20>, cls='logs_cls')
    ),
    entry_trades=dict(
        obj_type='records',
        field_aliases=(
            'entry_trade_records'
        ),
        wrap_func=<function <lambda> at 0x1648a5120>,
        indexing_func=functools.partial(<function records_indexing_func at 0x164888b80>, cls='entry_trades_cls'),
        resample_func=functools.partial(<function records_resample_func at 0x164888c20>, cls='entry_trades_cls')
    ),
    exit_trades=dict(
        obj_type='records',
        field_aliases=(
            'exit_trade_records'
        ),
        wrap_func=<function <lambda> at 0x1648a51c0>,
        indexing_func=functools.partial(<function records_indexing_func at 0x164888b80>, cls='exit_trades_cls'),
        resample_func=functools.partial(<function records_resample_func at 0x164888c20>, cls='exit_trades_cls')
    ),
    trades=dict(
        obj_type='records',
        field_aliases=(
            'trade_records'
        ),
        wrap_func=<function <lambda> at 0x1648a5260>,
        indexing_func=functools.partial(<function records_indexing_func at 0x164888b80>, cls='trades_cls'),
        resample_func=functools.partial(<function records_resample_func at 0x164888c20>, cls='trades_cls')
    ),
    trade_history=dict(),
    positions=dict(
        obj_type='records',
        field_aliases=(
            'position_records'
        ),
        wrap_func=<function <lambda> at 0x1648a5300>,
        indexing_func=functools.partial(<function records_indexing_func at 0x164888b80>, cls='positions_cls'),
        resample_func=functools.partial(<function records_resample_func at 0x164888c20>, cls='positions_cls')
    ),
    drawdowns=dict(
        obj_type='records',
        field_aliases=(
            'drawdown_records'
        ),
        wrap_func=<function <lambda> at 0x1648a53a0>,
        indexing_func=functools.partial(<function records_indexing_func at 0x164888b80>, cls='drawdowns_cls', groups_only=True),
        resample_func=functools.partial(<function records_resample_func at 0x164888c20>, cls='drawdowns_cls')
    ),
    init_position=dict(
        obj_type='red_array',
        group_by_aware=False
    ),
    asset_flow=dict(
        group_by_aware=False,
        resample_func='sum',
        resample_kwargs=dict(
            wrap_kwargs=dict(
                fillna=0.0
            )
        )
    ),
    long_asset_flow=dict(
        method_name='get_asset_flow',
        group_by_aware=False,
        method_kwargs=dict(
            direction='longonly'
        ),
        resample_func='sum',
        resample_kwargs=dict(
            wrap_kwargs=dict(
                fillna=0.0
            )
        )
    ),
    short_asset_flow=dict(
        method_name='get_asset_flow',
        group_by_aware=False,
        method_kwargs=dict(
            direction='shortonly'
        ),
        resample_func='sum',
        resample_kwargs=dict(
            wrap_kwargs=dict(
                fillna=0.0
            )
        )
    ),
    assets=dict(
        group_by_aware=False
    ),
    long_assets=dict(
        method_name='get_assets',
        group_by_aware=False,
        method_kwargs=dict(
            direction='longonly'
        )
    ),
    short_assets=dict(
        method_name='get_assets',
        group_by_aware=False,
        method_kwargs=dict(
            direction='shortonly'
        )
    ),
    position_mask=dict(),
    long_position_mask=dict(
        method_name='get_position_mask',
        method_kwargs=dict(
            direction='longonly'
        )
    ),
    short_position_mask=dict(
        method_name='get_position_mask',
        method_kwargs=dict(
            direction='shortonly'
        )
    ),
    position_coverage=dict(
        obj_type='red_array'
    ),
    long_position_coverage=dict(
        method_name='get_position_coverage',
        obj_type='red_array',
        method_kwargs=dict(
            direction='longonly'
        )
    ),
    short_position_coverage=dict(
        method_name='get_position_coverage',
        obj_type='red_array',
        method_kwargs=dict(
            direction='shortonly'
        )
    ),
    position_entry_price=dict(
        group_by_aware=False
    ),
    position_exit_price=dict(
        group_by_aware=False
    ),
    init_cash=dict(
        obj_type='red_array'
    ),
    cash_deposits=dict(
        resample_func='sum',
        resample_kwargs=dict(
            wrap_kwargs=dict(
                fillna=0.0
            )
        )
    ),
    total_cash_deposits=dict(
        obj_type='red_array'
    ),
    cash_earnings=dict(
        resample_func='sum',
        resample_kwargs=dict(
            wrap_kwargs=dict(
                fillna=0.0
            )
        )
    ),
    total_cash_earnings=dict(
        obj_type='red_array'
    ),
    cash_flow=dict(
        resample_func='sum',
        resample_kwargs=dict(
            wrap_kwargs=dict(
                fillna=0.0
            )
        )
    ),
    free_cash_flow=dict(
        method_name='get_cash_flow',
        method_kwargs=dict(
            free=True
        ),
        resample_func='sum',
        resample_kwargs=dict(
            wrap_kwargs=dict(
                fillna=0.0
            )
        )
    ),
    cash=dict(),
    position=dict(
        method_name='get_assets',
        group_by_aware=False
    ),
    debt=dict(
        method_name=None,
        group_by_aware=False
    ),
    locked_cash=dict(
        method_name=None,
        group_by_aware=False
    ),
    free_cash=dict(
        method_name='get_cash',
        method_kwargs=dict(
            free=True
        )
    ),
    init_price=dict(
        obj_type='red_array',
        group_by_aware=False
    ),
    init_position_value=dict(
        obj_type='red_array'
    ),
    init_value=dict(
        obj_type='red_array'
    ),
    input_value=dict(
        obj_type='red_array'
    ),
    asset_value=dict(),
    long_asset_value=dict(
        method_name='get_asset_value',
        method_kwargs=dict(
            direction='longonly'
        )
    ),
    short_asset_value=dict(
        method_name='get_asset_value',
        method_kwargs=dict(
            direction='shortonly'
        )
    ),
    gross_exposure=dict(),
    long_gross_exposure=dict(
        method_name='get_gross_exposure',
        method_kwargs=dict(
            direction='longonly'
        )
    ),
    short_gross_exposure=dict(
        method_name='get_gross_exposure',
        method_kwargs=dict(
            direction='shortonly'
        )
    ),
    net_exposure=dict(),
    value=dict(),
    allocations=dict(
        group_by_aware=False
    ),
    long_allocations=dict(
        method_name='get_allocations',
        method_kwargs=dict(
            direction='longonly'
        ),
        group_by_aware=False
    ),
    short_allocations=dict(
        method_name='get_allocations',
        method_kwargs=dict(
            direction='shortonly'
        ),
        group_by_aware=False
    ),
    total_profit=dict(
        obj_type='red_array'
    ),
    final_value=dict(
        obj_type='red_array'
    ),
    total_return=dict(
        obj_type='red_array'
    ),
    returns=dict(
        resample_func=<function returns_resample_func at 0x1648a4b80>
    ),
    log_returns=dict(
        method_name='get_returns',
        method_kwargs=dict(
            log_returns=True
        ),
        resample_func=functools.partial(<function returns_resample_func at 0x1648a4b80>, log_returns=True)
    ),
    daily_log_returns=dict(
        method_name='get_returns',
        method_kwargs=dict(
            daily_returns=True,
            log_returns=True
        ),
        resample_func=functools.partial(<function returns_resample_func at 0x1648a4b80>, log_returns=True)
    ),
    asset_pnl=dict(
        resample_func='sum',
        resample_kwargs=dict(
            wrap_kwargs=dict(
                fillna=0.0
            )
        )
    ),
    asset_returns=dict(
        resample_func=<function returns_resample_func at 0x1648a4b80>
    ),
    market_value=dict(),
    market_returns=dict(
        resample_func=<function returns_resample_func at 0x1648a4b80>
    ),
    bm_value=dict(),
    bm_returns=dict(
        resample_func=<function returns_resample_func at 0x1648a4b80>
    ),
    total_market_return=dict(
        obj_type='red_array'
    ),
    daily_returns=dict(
        resample_func=<function returns_resample_func at 0x1648a4b80>
    ),
    annual_returns=dict(
        resample_func=<function returns_resample_func at 0x1648a4b80>
    ),
    cumulative_returns=dict(),
    annualized_return=dict(
        obj_type='red_array'
    ),
    annualized_volatility=dict(
        obj_type='red_array'
    ),
    calmar_ratio=dict(
        obj_type='red_array'
    ),
    omega_ratio=dict(
        obj_type='red_array'
    ),
    sharpe_ratio=dict(
        obj_type='red_array'
    ),
    sharpe_ratio_std=dict(
        obj_type='red_array'
    ),
    prob_sharpe_ratio=dict(
        obj_type='red_array'
    ),
    deflated_sharpe_ratio=dict(
        obj_type='red_array'
    ),
    downside_risk=dict(
        obj_type='red_array'
    ),
    sortino_ratio=dict(
        obj_type='red_array'
    ),
    information_ratio=dict(
        obj_type='red_array'
    ),
    beta=dict(
        obj_type='red_array'
    ),
    alpha=dict(
        obj_type='red_array'
    ),
    tail_ratio=dict(
        obj_type='red_array'
    ),
    value_at_risk=dict(
        obj_type='red_array'
    ),
    cond_value_at_risk=dict(
        obj_type='red_array'
    ),
    capture_ratio=dict(
        obj_type='red_array'
    ),
    up_capture_ratio=dict(
        obj_type='red_array'
    ),
    down_capture_ratio=dict(
        obj_type='red_array'
    ),
    drawdown=dict(),
    max_drawdown=dict(
        obj_type='red_array'
    )
)

fix_wrapper_for_records function¶

fix_wrapper_for_records(
    pf
)

Allow flags for records that were restricted for portfolio.

records_indexing_func function¶

records_indexing_func(
    obj,
    wrapper_meta,
    cls,
    groups_only=False,
    **kwargs
)

Apply indexing function on records.

records_resample_func function¶

records_resample_func(
    obj,
    resampler,
    wrapper,
    cls,
    **kwargs
)

Apply resampling function on records.

returns_resample_func function¶

returns_resample_func(
    obj,
    resampler,
    wrapper,
    fill_with_zero=True,
    log_returns=False,
    **kwargs
)

Apply resampling function on returns.

MetaInOutputs class¶

MetaInOutputs(
    *args,
    **kwargs
)

Meta class that exposes a read-only class property MetaFields.in_output_config.

Superclasses

• builtins.type

Subclasses

• MetaPortfolio

in_output_config property¶

In-output config.

MetaPortfolio class¶

MetaPortfolio(
    *args,
    **kwargs
)

Meta class that exposes a read-only class property StatsBuilderMixin.metrics.

Superclasses

• MetaAnalyzable
• MetaInOutputs
• MetaPlotsBuilderMixin
• MetaStatsBuilderMixin
• builtins.type

Inherited members

• MetaAnalyzable.metrics
• MetaAnalyzable.subplots
• MetaInOutputs.in_output_config

Portfolio class¶

Portfolio(
    wrapper,
    order_records,
    *,
    close,
    open=None,
    high=None,
    low=None,
    log_records=None,
    cash_sharing=False,
    init_cash='auto',
    init_position=0.0,
    init_price=nan,
    cash_deposits=0.0,
    cash_deposits_as_input=None,
    cash_earnings=0.0,
    sim_start=None,
    sim_end=None,
    call_seq=None,
    in_outputs=None,
    use_in_outputs=None,
    bm_close=None,
    fillna_close=None,
    year_freq=None,
    returns_acc_defaults=None,
    trades_type=None,
    orders_cls=None,
    logs_cls=None,
    trades_cls=None,
    entry_trades_cls=None,
    exit_trades_cls=None,
    positions_cls=None,
    drawdowns_cls=None,
    weights=None,
    **kwargs
)

Class for simulating a portfolio and measuring its performance.

Args

wrapper : ArrayWrapper

Array wrapper.

See ArrayWrapper.

close : array_like

Last asset price at each time step.

order_records : array_like

A structured NumPy array of order records.

open : array_like

Open price of each bar.

high : array_like

High price of each bar.

low : array_like

Low price of each bar.

log_records : array_like

A structured NumPy array of log records.

cash_sharing : bool

Whether to share cash within the same group.

init_cash : InitCashMode or array_like of float

Initial capital.

Can be provided in a format suitable for flexible indexing.

init_position : array_like of float

Initial position.

Can be provided in a format suitable for flexible indexing.

init_price : array_like of float

Initial position price.

Can be provided in a format suitable for flexible indexing.

cash_deposits : array_like of float

Cash deposited/withdrawn at each timestamp.

Can be provided in a format suitable for flexible indexing.

cash_earnings : array_like of float

Earnings added at each timestamp.

Can be provided in a format suitable for flexible indexing.

sim_start : int, datetime_like, or array_like

Simulation start per column. Defaults to None.

sim_end : int, datetime_like, or array_like

Simulation end per column. Defaults to None.

call_seq : array_like of int

Sequence of calls per row and group. Defaults to None.

in_outputs : namedtuple

Named tuple with in-output objects.

To substitute Portfolio attributes, provide already broadcasted and grouped objects. Also see Portfolio.in_outputs_indexing_func() on how in-output objects are indexed.

use_in_outputs : bool

Whether to return in-output objects when calling properties.

bm_close : array_like

Last benchmark asset price at each time step.

fillna_close : bool

Whether to forward and backward fill NaN values in close.

Applied after the simulation to avoid NaNs in asset value.

See Portfolio.get_filled_close().

weights : array_like

Asset weights.

Applied to the initial position, initial cash, cash deposits, cash earnings, and orders.

trades_type : str or int

Default Trades to use across Portfolio.

See TradesType.

orders_cls : type

Class for wrapping order records.

logs_cls : type

Class for wrapping log records.

trades_cls : type

Class for wrapping trade records.

entry_trades_cls : type

Class for wrapping entry trade records.

exit_trades_cls : type

Class for wrapping exit trade records.

positions_cls : type

Class for wrapping position records.

drawdowns_cls : type

Class for wrapping drawdown records.

For defaults, see portfolio.

Superclasses

• Analyzable
• AttrResolverMixin
• Cacheable
• Chainable
• Comparable
• Configured
• ExtPandasIndexer
• HasSettings
• IndexApplier
• IndexingBase
• Itemable
• PandasIndexer
• Paramable
• Pickleable
• PlotsBuilderMixin
• PortfolioWithInOutputs
• Prettified
• SimRangeMixin
• StatsBuilderMixin
• Wrapping

Inherited members

• Analyzable.cls_dir
• Analyzable.column_only_select
• Analyzable.config
• Analyzable.group_select
• Analyzable.iloc
• Analyzable.indexing_kwargs
• Analyzable.loc
• Analyzable.range_only_select
• Analyzable.rec_state
• Analyzable.self_aliases
• Analyzable.wrapper
• Analyzable.xloc
• AttrResolverMixin.deep_getattr()
• AttrResolverMixin.resolve_attr()
• Cacheable.get_ca_setup()
• Chainable.pipe()
• Configured.copy()
• Configured.equals()
• Configured.get_writeable_attrs()
• Configured.prettify()
• Configured.replace()
• Configured.resolve_merge_kwargs()
• Configured.update_config()
• HasSettings.get_path_setting()
• HasSettings.get_path_settings()
• HasSettings.get_setting()
• HasSettings.get_settings()
• HasSettings.has_path_setting()
• HasSettings.has_path_settings()
• HasSettings.has_setting()
• HasSettings.has_settings()
• HasSettings.reset_settings()
• HasSettings.resolve_setting()
• HasSettings.resolve_settings_paths()
• HasSettings.set_settings()
• IndexApplier.add_levels()
• IndexApplier.drop_duplicate_levels()
• IndexApplier.drop_levels()
• IndexApplier.drop_redundant_levels()
• IndexApplier.rename_levels()
• IndexApplier.select_levels()
• IndexingBase.indexing_setter_func()
• PandasIndexer.xs()
• Pickleable.decode_config()
• Pickleable.decode_config_node()
• Pickleable.dumps()
• Pickleable.encode_config()
• Pickleable.encode_config_node()
• Pickleable.file_exists()
• Pickleable.getsize()
• Pickleable.load()
• Pickleable.loads()
• Pickleable.modify_state()
• Pickleable.resolve_file_path()
• Pickleable.save()
• PlotsBuilderMixin.build_subplots_doc()
• PlotsBuilderMixin.override_subplots_doc()
• PlotsBuilderMixin.plots()
• SimRangeMixin.column_stack_sim_end()
• SimRangeMixin.column_stack_sim_start()
• SimRangeMixin.fit_fig_to_sim_range()
• SimRangeMixin.get_sim_duration()
• SimRangeMixin.get_sim_end()
• SimRangeMixin.get_sim_end_index()
• SimRangeMixin.get_sim_start()
• SimRangeMixin.get_sim_start_index()
• SimRangeMixin.resample_sim_end()
• SimRangeMixin.resample_sim_start()
• SimRangeMixin.resolve_sim_end()
• SimRangeMixin.resolve_sim_end_value()
• SimRangeMixin.resolve_sim_start()
• SimRangeMixin.resolve_sim_start_value()
• SimRangeMixin.row_stack_sim_end()
• SimRangeMixin.row_stack_sim_start()
• SimRangeMixin.sim_duration
• SimRangeMixin.sim_end
• SimRangeMixin.sim_end_index
• SimRangeMixin.sim_end_indexing_func()
• SimRangeMixin.sim_start
• SimRangeMixin.sim_start_index
• SimRangeMixin.sim_start_indexing_func()
• StatsBuilderMixin.build_metrics_doc()
• StatsBuilderMixin.override_metrics_doc()
• StatsBuilderMixin.stats()
• Wrapping.apply_to_index()
• Wrapping.as_param()
• Wrapping.items()
• Wrapping.resolve_column_stack_kwargs()
• Wrapping.resolve_row_stack_kwargs()
• Wrapping.resolve_self()
• Wrapping.resolve_stack_kwargs()
• Wrapping.select_col()
• Wrapping.select_col_from_obj()
• Wrapping.split()
• Wrapping.split_apply()

allocations property¶

Portfolio.get_allocations() with default arguments.

alpha property¶

Portfolio.get_alpha() with default arguments.

annual_returns property¶

Portfolio.get_annual_returns() with default arguments.

annualized_return property¶

Portfolio.get_annualized_return() with default arguments.

annualized_volatility property¶

Portfolio.get_annualized_volatility() with default arguments.

apply_weights method¶

Portfolio.apply_weights(
    weights=None,
    rescale=False,
    group_by=None,
    apply_group_by=False,
    **kwargs
)

Get view of portfolio with asset weights applied and optionally rescaled.

If rescale is True, weights are rescaled in respect to other weights in the same group. For example, weights 0.5 and 0.5 are rescaled to 1.0 and 1.0 respectively, while weights 0.7 and 0.3 are rescaled to 1.4 (1.4 * 0.5 = 0.7) and 0.6 (0.6 * 0.5 = 0.3) respectively.

asset_flow property¶

Portfolio.get_asset_flow() with default arguments.

asset_pnl property¶

Portfolio.get_asset_pnl() with default arguments.

asset_returns property¶

Portfolio.get_asset_returns() with default arguments.

asset_value property¶

Portfolio.get_asset_value() with default arguments.

assets property¶

Portfolio.get_assets() with default arguments.

beta property¶

Portfolio.get_beta() with default arguments.

bm_close property¶

Benchmark price per unit series.

bm_returns property¶

Portfolio.get_bm_returns() with default arguments.

bm_value property¶

Portfolio.get_bm_value() with default arguments.

build_in_output_config_doc class method¶

Portfolio.build_in_output_config_doc(
    source_cls=None
)

Build in-output config documentation.

call_seq property¶

Sequence of calls per row and group.

calmar_ratio property¶

Portfolio.get_calmar_ratio() with default arguments.

capture_ratio property¶

Portfolio.get_capture_ratio() with default arguments.

cash property¶

Portfolio.get_cash() with default arguments.

cash_deposits property¶

Portfolio.get_cash_deposits() with default arguments.

cash_deposits_as_input property¶

Whether to add cash deposits to the input value when calculating returns.

Otherwise, will subtract them from the output value.

cash_earnings property¶

Portfolio.get_cash_earnings() with default arguments.

cash_flow property¶

Portfolio.get_cash_flow() with default arguments.

cash_sharing property¶

Whether to share cash within the same group.

close property¶

Last asset price at each time step.

close_flex property¶

Portfolio.close in a format suitable for flexible indexing.

column_stack class method¶

Portfolio.column_stack(
    *objs,
    wrapper_kwargs=None,
    group_by=None,
    ffill_close=False,
    fbfill_close=False,
    **kwargs
)

Stack multiple Portfolio instances along columns.

Uses ArrayWrapper.column_stack() to stack the wrappers.

Cash sharing must be the same among all objects.

Two-dimensional arrays are stacked using ArrayWrapper.column_stack_arrs() while one-dimensional arrays are stacked using ArrayWrapper.concat_arrs(). In-outputs are stacked using Portfolio.column_stack_in_outputs(). Records are stacked using Records.column_stack_records_arrs().

column_stack_in_outputs class method¶

Portfolio.column_stack_in_outputs(
    *objs,
    **kwargs
)

Stack Portfolio.in_outputs along columns.

All in-output tuples must be either None or have the same fields.

If the field can be found in the attributes of this Portfolio instance, reads the attribute's options to get requirements for the type and layout of the in-output object.

For each field in Portfolio.in_outputs, resolves the field's options by parsing its name with Portfolio.parse_field_options() and also looks for options in Portfolio.in_output_config. Performs stacking on the in-output objects of the same field using Portfolio.column_stack_objs().

column_stack_objs class method¶

Portfolio.column_stack_objs(
    objs,
    wrappers,
    grouping='columns_or_groups',
    obj_name=None,
    obj_type=None,
    wrapper=None,
    cash_sharing=False,
    column_stack_func=None,
    **kwargs
)

Stack (one and two-dimensional) objects along column.

column_stack_func must take the portfolio class, and all the arguments passed to this method. If you don't need any of the arguments, make column_stack_func accept them as **kwargs.

If all the objects are None, boolean, or empty, returns the first one.

cond_value_at_risk property¶

Portfolio.get_cond_value_at_risk() with default arguments.

cumulative_returns property¶

Portfolio.get_cumulative_returns() with default arguments.

daily_log_returns property¶

Portfolio.get_returns() with arguments {'daily_returns': True, 'log_returns': True}.

daily_returns property¶

Portfolio.get_daily_returns() with default arguments.

debt property¶

Portfolio.None with default arguments.

deflated_sharpe_ratio property¶

Portfolio.get_deflated_sharpe_ratio() with default arguments.

disable_weights method¶

Portfolio.disable_weights(
    **kwargs
)

Get view of portfolio with asset weights disabled.

down_capture_ratio property¶

Portfolio.get_down_capture_ratio() with default arguments.

downside_risk property¶

Portfolio.get_downside_risk() with default arguments.

drawdown property¶

Portfolio.get_drawdown() with default arguments.

drawdowns property¶

Portfolio.get_drawdowns() with default arguments.

drawdowns_cls property¶

Class for wrapping drawdown records.

entry_trades property¶

Portfolio.get_entry_trades() with default arguments.

entry_trades_cls property¶

Class for wrapping entry trade records.

exit_trades property¶

Portfolio.get_exit_trades() with default arguments.

exit_trades_cls property¶

Class for wrapping exit trade records.

filled_bm_close property¶

Portfolio.get_filled_bm_close() with default arguments.

filled_close property¶

Portfolio.get_filled_close() with default arguments.

fillna_close property¶

Whether to forward-backward fill NaN values in Portfolio.close.

final_value property¶

Portfolio.get_final_value() with default arguments.

free_cash property¶

Portfolio.get_cash() with arguments {'free': True}.

free_cash_flow property¶

Portfolio.get_cash_flow() with arguments {'free': True}.

from_def_order_func class method¶

Portfolio.from_def_order_func(
    close,
    size=None,
    size_type=None,
    direction=None,
    price=None,
    fees=None,
    fixed_fees=None,
    slippage=None,
    min_size=None,
    max_size=None,
    size_granularity=None,
    leverage=None,
    leverage_mode=None,
    reject_prob=None,
    price_area_vio_mode=None,
    allow_partial=None,
    raise_reject=None,
    log=None,
    pre_segment_func_nb=None,
    order_func_nb=None,
    flex_order_func_nb=None,
    val_price=None,
    sim_start=None,
    sim_end=None,
    call_seq=None,
    flexible=False,
    broadcast_named_args=None,
    broadcast_kwargs=None,
    chunked=None,
    return_preparer=False,
    return_prep_result=False,
    return_sim_out=False,
    **kwargs
)

Build portfolio from the default order function.

Default order function takes size, price, fees, and other available information, and issues an order at each column and time step. Additionally, it uses a segment preprocessing function that overrides the valuation price and sorts the call sequence. This way, it behaves similarly to Portfolio.from_orders(), but allows injecting pre- and postprocessing functions to have more control over the execution. It also knows how to chunk each argument. The only disadvantage is that Portfolio.from_orders() is more optimized towards performance (up to 5x).

If flexible is True:

• pre_segment_func_nb is def_flex_pre_segment_func_nb()
• flex_order_func_nb is def_flex_order_func_nb()

If flexible is False:

• pre_segment_func_nb is def_pre_segment_func_nb()
• order_func_nb is def_order_func_nb()

Prepared by FDOFPreparer.

For details on other arguments, see Portfolio.from_orders() and Portfolio.from_order_func().

Usage

• Working with Portfolio.from_def_order_func() is a similar experience as working with Portfolio.from_orders():

>>> close = pd.Series([1, 2, 3, 4, 5])
>>> pf = vbt.Portfolio.from_def_order_func(close, 10)

>>> pf.assets
0    10.0
1    20.0
2    30.0
3    40.0
4    40.0
dtype: float64
>>> pf.cash
0    90.0
1    70.0
2    40.0
3     0.0
4     0.0
dtype: float64

• Equal-weighted portfolio as in the example under Portfolio.from_order_func() but much less verbose and with asset value pre-computed during the simulation (= faster):

>>> np.random.seed(42)
>>> close = np.random.uniform(1, 10, size=(5, 3))

>>> @njit
... def post_segment_func_nb(c):
...     for col in range(c.from_col, c.to_col):
...         c.in_outputs.asset_value_pc[c.i, col] = c.last_position[col] * c.last_val_price[col]

>>> pf = vbt.Portfolio.from_def_order_func(
...     close,
...     size=1/3,
...     size_type='targetpercent',
...     direction='longonly',
...     fees=0.001,
...     fixed_fees=1.,
...     slippage=0.001,
...     segment_mask=2,
...     cash_sharing=True,
...     group_by=True,
...     call_seq='auto',
...     post_segment_func_nb=post_segment_func_nb,
...     call_post_segment=True,
...     in_outputs=dict(asset_value_pc=vbt.RepEval('np.empty_like(close)'))
... )

>>> asset_value = pf.wrapper.wrap(pf.in_outputs.asset_value_pc, group_by=False)
>>> asset_value.vbt.plot().show()

from_holding class method¶

Portfolio.from_holding(
    close,
    direction=None,
    at_first_valid_in='close',
    close_at_end=None,
    dynamic_mode=False,
    **kwargs
)

Simulate portfolio from plain holding using signals.

If close_at_end is True, will place an opposite signal at the very end.

**kwargs are passed to the class method Portfolio.from_signals().

from_optimizer class method¶

Portfolio.from_optimizer(
    close,
    optimizer,
    pf_method='from_orders',
    squeeze_groups=True,
    dropna=None,
    fill_value=nan,
    size_type='targetpercent',
    direction=None,
    cash_sharing=True,
    call_seq='auto',
    group_by=None,
    **kwargs
)

Build portfolio from an optimizer of type PortfolioOptimizer.

Uses Portfolio.from_orders() as the base simulation method.

The size type is 'targetpercent'. If there are positive and negative values, the direction is automatically set to 'both', otherwise to 'longonly' for positive-only and shortonly for negative-only values. Also, the cash sharing is set to True, the call sequence is set to 'auto', and the grouper is set to the grouper of the optimizer by default.

Usage

>>> close = pd.DataFrame({
...     "MSFT": [1, 2, 3, 4, 5],
...     "GOOG": [5, 4, 3, 2, 1],
...     "AAPL": [1, 2, 3, 2, 1]
... }, index=pd.date_range(start="2020-01-01", periods=5))

>>> pfo = vbt.PortfolioOptimizer.from_random(
...     close.vbt.wrapper,
...     every="2D",
...     seed=42
... )
>>> pfo.fill_allocations()
                 MSFT      GOOG      AAPL
2020-01-01   0.182059  0.462129  0.355812
2020-01-02        NaN       NaN       NaN
2020-01-03   0.657381  0.171323  0.171296
2020-01-04        NaN       NaN       NaN
2020-01-05   0.038078  0.567845  0.394077

>>> pf = vbt.Portfolio.from_optimizer(close, pfo)
>>> pf.get_asset_value(group_by=False).vbt / pf.value
alloc_group                         group
                 MSFT      GOOG      AAPL
2020-01-01   0.182059  0.462129  0.355812  << rebalanced
2020-01-02   0.251907  0.255771  0.492322
2020-01-03   0.657381  0.171323  0.171296  << rebalanced
2020-01-04   0.793277  0.103369  0.103353
2020-01-05   0.038078  0.567845  0.394077  << rebalanced

from_order_func class method¶

Portfolio.from_order_func(
    close,
    *,
    init_cash=None,
    init_position=None,
    init_price=None,
    cash_deposits=None,
    cash_earnings=None,
    cash_sharing=None,
    sim_start=None,
    sim_end=None,
    call_seq=None,
    attach_call_seq=None,
    segment_mask=None,
    call_pre_segment=None,
    call_post_segment=None,
    pre_sim_func_nb=None,
    pre_sim_args=(),
    post_sim_func_nb=None,
    post_sim_args=(),
    pre_group_func_nb=None,
    pre_group_args=(),
    post_group_func_nb=None,
    post_group_args=(),
    pre_row_func_nb=None,
    pre_row_args=(),
    post_row_func_nb=None,
    post_row_args=(),
    pre_segment_func_nb=None,
    pre_segment_args=(),
    post_segment_func_nb=None,
    post_segment_args=(),
    order_func_nb=None,
    order_args=(),
    flex_order_func_nb=None,
    flex_order_args=(),
    post_order_func_nb=None,
    post_order_args=(),
    open=None,
    high=None,
    low=None,
    ffill_val_price=None,
    update_value=None,
    fill_pos_info=None,
    track_value=None,
    row_wise=None,
    max_order_records=None,
    max_log_records=None,
    in_outputs=None,
    seed=None,
    group_by=None,
    broadcast_named_args=None,
    broadcast_kwargs=None,
    template_context=None,
    keep_inout_flex=None,
    jitted=None,
    chunked=None,
    staticized=None,
    bm_close=None,
    records=None,
    return_preparer=False,
    return_prep_result=False,
    return_sim_out=False,
    **kwargs
)

Build portfolio from a custom order function.

For more details on individual simulation functions:

• order_func_nb: See from_order_func_nb()
• order_func_nb and row_wise: See from_order_func_rw_nb()
• flex_order_func_nb: See from_flex_order_func_nb()
• flex_order_func_nb and row_wise: See from_flex_order_func_rw_nb()

Prepared by FOFPreparer.

Args

close : array_like, OHLCDataMixin, FOFPreparer, or PFPrepResult

Latest asset price at each time step. Will broadcast.

If an instance of OHLCDataMixin, will extract the open, high, low, and close price.

Used for calculating unrealized PnL and portfolio value.

init_cash : InitCashMode, float or array_like

See Portfolio.from_orders().

init_position : float or array_like

See Portfolio.from_orders().

init_price : float or array_like

See Portfolio.from_orders().

cash_deposits : float or array_like

See Portfolio.from_orders().

cash_earnings : float or array_like

See Portfolio.from_orders().

cash_sharing : bool

Whether to share cash within the same group.

If group_by is None, group_by becomes True to form a single group with cash sharing.

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).

call_seq : CallSeqType or array_like

Default sequence of calls per row and group.

• Use CallSeqType to select a sequence type.
• Set to array to specify custom sequence. Will not broadcast.

Note

CallSeqType.Auto must be implemented manually. Use sort_call_seq_1d_nb() or sort_call_seq_out_1d_nb() in pre_segment_func_nb.

attach_call_seq : bool

See Portfolio.from_orders().

segment_mask : int or array_like of bool

Mask of whether a particular segment should be executed.

Supplying an integer will activate every n-th row. Supplying a boolean or an array of boolean will broadcast to the number of rows and groups.

Does not broadcast together with close and broadcast_named_args, only against the final shape.

call_pre_segment : bool

Whether to call pre_segment_func_nb regardless of segment_mask.

call_post_segment : bool

Whether to call post_segment_func_nb regardless of segment_mask.

pre_sim_func_nb : callable

Function called before simulation. Defaults to no_pre_func_nb().

pre_sim_args : tuple

Packed arguments passed to pre_sim_func_nb.

post_sim_func_nb : callable

Function called after simulation. Defaults to no_post_func_nb().

post_sim_args : tuple

Packed arguments passed to post_sim_func_nb.

pre_group_func_nb : callable

Function called before each group. Defaults to no_pre_func_nb().

Called only if row_wise is False.

pre_group_args : tuple

Packed arguments passed to pre_group_func_nb.

post_group_func_nb : callable

Function called after each group. Defaults to no_post_func_nb().

Called only if row_wise is False.

post_group_args : tuple

Packed arguments passed to post_group_func_nb.

pre_row_func_nb : callable

Function called before each row. Defaults to no_pre_func_nb().

Called only if row_wise is True.

pre_row_args : tuple

Packed arguments passed to pre_row_func_nb.

post_row_func_nb : callable

Function called after each row. Defaults to no_post_func_nb().

Called only if row_wise is True.

post_row_args : tuple

Packed arguments passed to post_row_func_nb.

pre_segment_func_nb : callable

Function called before each segment. Defaults to no_pre_func_nb().

pre_segment_args : tuple

Packed arguments passed to pre_segment_func_nb.

post_segment_func_nb : callable

Function called after each segment. Defaults to no_post_func_nb().

post_segment_args : tuple

Packed arguments passed to post_segment_func_nb.

order_func_nb : callable

Order generation function.

order_args

Packed arguments passed to order_func_nb.

flex_order_func_nb : callable

Flexible order generation function.

flex_order_args

Packed arguments passed to flex_order_func_nb.

post_order_func_nb : callable

Callback that is called after the order has been processed.

post_order_args : tuple

Packed arguments passed to post_order_func_nb.

open : array_like of float

See Portfolio.from_orders().

high : array_like of float

See Portfolio.from_orders().

low : array_like of float

See Portfolio.from_orders().

ffill_val_price : bool

Whether to track valuation price only if it's known.

Otherwise, unknown close will lead to NaN in valuation price at the next timestamp.

update_value : bool

Whether to update group value after each filled order.

fill_pos_info : bool

Whether to fill position record.

Disable this to make simulation faster for simple use cases.

track_value : bool

Whether to track value metrics such as the current valuation price, value, and return.

Disable this to make simulation faster for simple use cases.

row_wise : bool

Whether to iterate over rows rather than columns/groups.

max_order_records : int

The max number of order records expected to be filled at each column. Defaults to the number of rows in the broadcasted shape.

Set to a lower number if you run out of memory, to 0 to not fill, and to a higher number if there are more than one order expected at each timestamp.

max_log_records : int

The max number of log records expected to be filled at each column. Defaults to the number of rows in the broadcasted shape.

Set to a lower number if you run out of memory, to 0 to not fill, and to a higher number if there are more than one order expected at each timestamp.

in_outputs : mapping_like

Mapping with in-output objects.

Will be available via Portfolio.in_outputs as a named tuple.

To substitute Portfolio attributes, provide already broadcasted and grouped objects, for example, by using broadcast_named_args and templates. Also see Portfolio.in_outputs_indexing_func() on how in-output objects are indexed.

When chunking, make sure to provide the chunk taking specification and the merging function. See merge_sim_outs().

Note

When using Numba below 0.54, in_outputs cannot be a mapping, but must be a named tuple defined globally so Numba can introspect its attributes for pickling.

seed : int

See Portfolio.from_orders().

group_by : any

See Portfolio.from_orders().

broadcast_named_args : dict

See Portfolio.from_signals().

broadcast_kwargs : dict

See Portfolio.from_orders().

template_context : mapping

See Portfolio.from_signals().

keep_inout_flex : bool

Whether to keep arrays that can be edited in-place raw when broadcasting.

Disable this to be able to edit segment_mask, cash_deposits, and cash_earnings during the simulation.

jitted : any

See Portfolio.from_orders().

Note

Disabling jitting will not disable jitter (such as Numba) on other functions, only on the main (simulation) function. If neccessary, you should ensure that every other function is not compiled as well. For example, when working with Numba, you can do this by using the py_func attribute of that function. Or, you can disable Numba entirely by running os.environ['NUMBA_DISABLE_JIT'] = '1' before importing vectorbtpro.

Warning

Parallelization assumes that groups are independent and there is no data flowing between them.

chunked : any

See resolve_chunked_option().

staticized : bool, dict, hashable, or callable

Keyword arguments or task id for staticizing.

If True or dictionary, will be passed as keyword arguments to cut_and_save_func() to save a cacheable version of the simulator to a file. If a hashable or callable, will be used as a task id of an already registered jittable and chunkable simulator. Dictionary allows additional options override and reload to override and reload an already existing module respectively.

bm_close : array_like

See Portfolio.from_orders().

records : array_like

See Portfolio.from_orders().

return_preparer : bool

See Portfolio.from_orders().

return_prep_result : bool

See Portfolio.from_orders().

return_sim_out : bool

See Portfolio.from_orders().

**kwargs

Keyword arguments passed to the Portfolio constructor.

For defaults, see portfolio. Those defaults are not used to fill NaN values after reindexing: vectorbt uses its own sensible defaults, which are usually NaN for floating arrays and default flags for integer arrays. Use BCO with fill_value to override.

Usage

• Buy 10 units each tick using closing price:

>>> @njit
... def order_func_nb(c, size):
...     return vbt.pf_nb.order_nb(size=size)

>>> close = pd.Series([1, 2, 3, 4, 5])
>>> pf = vbt.Portfolio.from_order_func(
...     close,
...     order_func_nb=order_func_nb,
...     order_args=(10,)
... )

>>> pf.assets
0    10.0
1    20.0
2    30.0
3    40.0
4    40.0
dtype: float64
>>> pf.cash
0    90.0
1    70.0
2    40.0
3     0.0
4     0.0
dtype: float64

• Reverse each position by first closing it. Keep state of last position to determine which position to open next (just as an example, there are easier ways to do this):

>>> @njit
... def pre_group_func_nb(c):
...     last_pos_state = np.array([-1])
...     return (last_pos_state,)

>>> @njit
... def order_func_nb(c, last_pos_state):
...     if c.position_now != 0:
...         return vbt.pf_nb.close_position_nb()
...
...     if last_pos_state[0] == 1:
...         size = -np.inf  # open short
...         last_pos_state[0] = -1
...     else:
...         size = np.inf  # open long
...         last_pos_state[0] = 1
...     return vbt.pf_nb.order_nb(size=size)

>>> pf = vbt.Portfolio.from_order_func(
...     close,
...     order_func_nb=order_func_nb,
...     pre_group_func_nb=pre_group_func_nb
... )

>>> pf.assets
0    100.000000
1      0.000000
2    -66.666667
3      0.000000
4     26.666667
dtype: float64
>>> pf.cash
0      0.000000
1    200.000000
2    400.000000
3    133.333333
4      0.000000
dtype: float64

• Equal-weighted portfolio as in the example under from_order_func_nb():

>>> @njit
... def pre_group_func_nb(c):
...     order_value_out = np.empty(c.group_len, dtype=np.float_)
...     return (order_value_out,)

>>> @njit
... def pre_segment_func_nb(c, order_value_out, size, price, size_type, direction):
...     for col in range(c.from_col, c.to_col):
...         c.last_val_price[col] = vbt.pf_nb.select_from_col_nb(c, col, price)
...     vbt.pf_nb.sort_call_seq_nb(c, size, size_type, direction, order_value_out)
...     return ()

>>> @njit
... def order_func_nb(c, size, price, size_type, direction, fees, fixed_fees, slippage):
...     return vbt.pf_nb.order_nb(
...         size=vbt.pf_nb.select_nb(c, size),
...         price=vbt.pf_nb.select_nb(c, price),
...         size_type=vbt.pf_nb.select_nb(c, size_type),
...         direction=vbt.pf_nb.select_nb(c, direction),
...         fees=vbt.pf_nb.select_nb(c, fees),
...         fixed_fees=vbt.pf_nb.select_nb(c, fixed_fees),
...         slippage=vbt.pf_nb.select_nb(c, slippage)
...     )

>>> np.random.seed(42)
>>> close = np.random.uniform(1, 10, size=(5, 3))
>>> size_template = vbt.RepEval('np.array([[1 / group_lens[0]]])')

>>> pf = vbt.Portfolio.from_order_func(
...     close,
...     order_func_nb=order_func_nb,
...     order_args=(
...         size_template,
...         vbt.Rep('price'),
...         vbt.Rep('size_type'),
...         vbt.Rep('direction'),
...         vbt.Rep('fees'),
...         vbt.Rep('fixed_fees'),
...         vbt.Rep('slippage'),
...     ),
...     segment_mask=2,  # rebalance every second tick
...     pre_group_func_nb=pre_group_func_nb,
...     pre_segment_func_nb=pre_segment_func_nb,
...     pre_segment_args=(
...         size_template,
...         vbt.Rep('price'),
...         vbt.Rep('size_type'),
...         vbt.Rep('direction')
...     ),
...     broadcast_named_args=dict(  # broadcast against each other
...         price=close,
...         size_type=vbt.pf_enums.SizeType.TargetPercent,
...         direction=vbt.pf_enums.Direction.LongOnly,
...         fees=0.001,
...         fixed_fees=1.,
...         slippage=0.001
...     ),
...     template_context=dict(np=np),  # required by size_template
...     cash_sharing=True, group_by=True,  # one group with cash sharing
... )

>>> pf.get_asset_value(group_by=False).vbt.plot().show()

Templates are a very powerful tool to prepare any custom arguments after they are broadcast and before they are passed to the simulation function. In the example above, we use broadcast_named_args to broadcast some arguments against each other and templates to pass those objects to callbacks. Additionally, we used an evaluation template to compute the size based on the number of assets in each group.

You may ask: why should we bother using broadcasting and templates if we could just pass size=1/3? Because of flexibility those features provide: we can now pass whatever parameter combinations we want and it will work flawlessly. For example, to create two groups of equally-allocated positions, we need to change only two parameters:

>>> close = np.random.uniform(1, 10, size=(5, 6))  # 6 columns instead of 3
>>> group_by = ['g1', 'g1', 'g1', 'g2', 'g2', 'g2']  # 2 groups instead of 1
>>> # Replace close and group_by in the example above

>>> pf['g1'].get_asset_value(group_by=False).vbt.plot().show()

>>> pf['g2'].get_asset_value(group_by=False).vbt.plot().show()

• Combine multiple exit conditions. Exit early if the price hits some threshold before an actual exit:

>>> @njit
... def pre_sim_func_nb(c):
...     # We need to define stop price per column once
...     stop_price = np.full(c.target_shape[1], np.nan, dtype=np.float_)
...     return (stop_price,)

>>> @njit
... def order_func_nb(c, stop_price, entries, exits, size):
...     # Select info related to this order
...     entry_now = vbt.pf_nb.select_nb(c, entries)
...     exit_now = vbt.pf_nb.select_nb(c, exits)
...     size_now = vbt.pf_nb.select_nb(c, size)
...     price_now = vbt.pf_nb.select_nb(c, c.close)
...     stop_price_now = stop_price[c.col]
...
...     # Our logic
...     if entry_now:
...         if c.position_now == 0:
...             return vbt.pf_nb.order_nb(
...                 size=size_now,
...                 price=price_now,
...                 direction=vbt.pf_enums.Direction.LongOnly)
...     elif exit_now or price_now >= stop_price_now:
...         if c.position_now > 0:
...             return vbt.pf_nb.order_nb(
...                 size=-size_now,
...                 price=price_now,
...                 direction=vbt.pf_enums.Direction.LongOnly)
...     return vbt.pf_enums.NoOrder

>>> @njit
... def post_order_func_nb(c, stop_price, stop):
...     # Same broadcasting as for size
...     stop_now = vbt.pf_nb.select_nb(c, stop)
...
...     if c.order_result.status == vbt.pf_enums.OrderStatus.Filled:
...         if c.order_result.side == vbt.pf_enums.OrderSide.Buy:
...             # Position entered: Set stop condition
...             stop_price[c.col] = (1 + stop_now) * c.order_result.price
...         else:
...             # Position exited: Remove stop condition
...             stop_price[c.col] = np.nan

>>> def simulate(close, entries, exits, size, stop):
...     return vbt.Portfolio.from_order_func(
...         close,
...         order_func_nb=order_func_nb,
...         order_args=(vbt.Rep('entries'), vbt.Rep('exits'), vbt.Rep('size')),
...         pre_sim_func_nb=pre_sim_func_nb,
...         post_order_func_nb=post_order_func_nb,
...         post_order_args=(vbt.Rep('stop'),),
...         broadcast_named_args=dict(  # broadcast against each other
...             entries=entries,
...             exits=exits,
...             size=size,
...             stop=stop
...         )
...     )

>>> close = pd.Series([10, 11, 12, 13, 14])
>>> entries = pd.Series([True, True, False, False, False])
>>> exits = pd.Series([False, False, False, True, True])
>>> simulate(close, entries, exits, np.inf, 0.1).asset_flow
0    10.0
1     0.0
2   -10.0
3     0.0
4     0.0
dtype: float64

>>> simulate(close, entries, exits, np.inf, 0.2).asset_flow
0    10.0
1     0.0
2   -10.0
3     0.0
4     0.0
dtype: float64

>>> simulate(close, entries, exits, np.inf, np.nan).asset_flow
0    10.0
1     0.0
2     0.0
3   -10.0
4     0.0
dtype: float64

The reason why stop of 10% does not result in an order at the second time step is because it comes at the same time as entry, so it must wait until no entry is present. This can be changed by replacing the statement "elif" with "if", which would execute an exit regardless if an entry is present (similar to using ConflictMode.Opposite in Portfolio.from_signals()).

We can also test the parameter combinations above all at once (thanks to broadcasting using broadcast()):

>>> stop = pd.DataFrame([[0.1, 0.2, np.nan]])
>>> simulate(close, entries, exits, np.inf, stop).asset_flow
      0     1     2
0  10.0  10.0  10.0
1   0.0   0.0   0.0
2 -10.0 -10.0   0.0
3   0.0   0.0 -10.0
4   0.0   0.0   0.0

Or much simpler using Cartesian product:

>>> stop = vbt.Param([0.1, 0.2, np.nan])
>>> simulate(close, entries, exits, np.inf, stop).asset_flow
threshold   0.1   0.2   NaN
0          10.0  10.0  10.0
1           0.0   0.0   0.0
2         -10.0 -10.0   0.0
3           0.0   0.0 -10.0
4           0.0   0.0   0.0

This works because pd.Index automatically translates into BCO with product set to True.

• Let's illustrate how to generate multiple orders per symbol and bar. For each bar, buy at open and sell at close:

>>> @njit
... def flex_order_func_nb(c, size):
...     if c.call_idx == 0:
...         return c.from_col, vbt.pf_nb.order_nb(size=size, price=c.open[c.i, c.from_col])
...     if c.call_idx == 1:
...         return c.from_col, vbt.pf_nb.close_position_nb(price=c.close[c.i, c.from_col])
...     return -1, vbt.pf_enums.NoOrder

>>> open = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
>>> close = pd.DataFrame({'a': [2, 3, 4], 'b': [3, 4, 5]})
>>> size = 1
>>> pf = vbt.Portfolio.from_order_func(
...     close,
...     flex_order_func_nb=flex_order_func_nb,
...     flex_order_args=(size,),
...     open=open,
...     max_order_records=close.shape[0] * 2
... )

>>> pf.orders.readable
    Order Id Column  Timestamp  Size  Price  Fees  Side
0          0      a          0   1.0    1.0   0.0   Buy
1          1      a          0   1.0    2.0   0.0  Sell
2          2      a          1   1.0    2.0   0.0   Buy
3          3      a          1   1.0    3.0   0.0  Sell
4          4      a          2   1.0    3.0   0.0   Buy
5          5      a          2   1.0    4.0   0.0  Sell
6          0      b          0   1.0    4.0   0.0   Buy
7          1      b          0   1.0    3.0   0.0  Sell
8          2      b          1   1.0    5.0   0.0   Buy
9          3      b          1   1.0    4.0   0.0  Sell
10         4      b          2   1.0    6.0   0.0   Buy
11         5      b          2   1.0    5.0   0.0  Sell