vectorbt

https://vectorbt.dev/
Admin
vectorbt is a Python package for high-performance quantitative analysis and backtesting of trading...
Tokens:658,721
Snippets:5,872
Trust Score:8
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install VectorBT from Repository

Source: https://vectorbt.dev/getting-started/contributing?q=

Install VectorBT in editable mode after cloning the repository. This is the first step for setting up the development environment.

```bash
pip uninstall vectorbt
git clone https://github.com/polakowo/vectorbt.git
cd vectorbt
pip install -e .
```

--------------------------------

### Install VectorBT with all integrations and Rust engine

Source: https://vectorbt.dev/getting-started/installation

Install VectorBT with both all optional integrations and the Rust engine. This is the most complete installation option.

```bash
pip install -U "vectorbt[full,rust]"
```

--------------------------------

### Install VectorBT

Source: https://vectorbt.dev/

Installation commands for various VectorBT feature sets.

```bash
pip install -U vectorbt
```

```bash
pip install -U "vectorbt[rust]"
```

```bash
pip install -U "vectorbt[full]"
```

```bash
pip install -U "vectorbt[full,rust]"
```

--------------------------------

### TelegramBot.start

Source: https://vectorbt.dev/api/messaging/telegram

Starts the Telegram bot instance.

```APIDOC
## TelegramBot.start(in_background=False, **kwargs)

### Description
Starts the bot. Additional kwargs are passed to the underlying polling mechanism.

### Parameters
- **in_background** (bool) - Optional - Whether to start the bot in a background thread.
```

--------------------------------

### Install VectorBT with pip

Source: https://vectorbt.dev/getting-started/installation

Use this command to install the base VectorBT package. Ensure pip is up-to-date.

```bash
pip install -U vectorbt
```

--------------------------------

### TelegramBot.start_callback method

Source: https://vectorbt.dev/api/messaging/telegram?q=

Callback for the start command.

```python
TelegramBot.start_callback(
    update,
    context
)
```

--------------------------------

### Install VectorBT with all optional integrations

Source: https://vectorbt.dev/getting-started/installation

Install VectorBT with all optional integrations, such as TA-Lib and Pandas TA. This provides the most comprehensive feature set.

```bash
pip install -U "vectorbt[full]"
```

--------------------------------

### Get Indicator Run Method Help

Source: https://vectorbt.dev/api/indicators/factory?q=

Use the `help` function to get detailed information about the arguments accepted by an indicator's `run` method. This includes inputs, parameters, outputs, and options for hiding parameter columns.

```python
>>> help(MyInd.run)
Help on method run:

run(price, window, short_name='custom', hide_params=None, hide_default=True, **kwargs) method of builtins.type instance
    Run `Indicator` indicator.

    * Inputs: `price`
    * Parameters: `window`
    * Outputs: `ma`

    Pass a list of parameter names as `hide_params` to hide their column levels.
    Set `hide_default` to False to show the column levels of the parameters with a default value.

    Other keyword arguments are passed to `vectorbt.indicators.factory.run_pipeline`.
```

--------------------------------

### ScheduleManager.start Method

Source: https://vectorbt.dev/api/utils/schedule_

Starts running pending jobs in a loop.

```APIDOC
## ScheduleManager.start Method

### Description
Run pending jobs in a loop.

### Parameters
- **sleep** (int) - The time in seconds to sleep between checking for pending jobs. Defaults to 1.

### Method
`start(sleep=1)`
```

--------------------------------

### Run a Basic Backtest

Source: https://vectorbt.dev/

Example of downloading data and calculating total profit using a holding portfolio.

```python
>>> import vectorbt as vbt

>>> data = vbt.YFData.download("BTC-USD")
>>> price = data.get("Close")
>>> pf = vbt.Portfolio.from_holding(price, init_cash=100)
>>> print(pf.total_profit())

17089.25554191831
```

--------------------------------

### Install VectorBT from local clone

Source: https://vectorbt.dev/getting-started/installation

Installs the VectorBT package in editable mode after cloning the repository. This allows for direct code modifications.

```bash
pip install -e vectorbt
```

--------------------------------

### Example Usage of MSTD Plot

Source: https://vectorbt.dev/api/indicators/basic

Example demonstrating how to run and plot the MSTD indicator with a specified window.

```python
>>> vbt.MSTD.run(ohlcv['Close'], 10).plot()

```

--------------------------------

### Implement a Protocol Class

Source: https://vectorbt.dev/api/utils/decorators

Example implementation of a class that satisfies the protocol.

```python
def meth(self) -> int:
    return 0
```

--------------------------------

### Install VectorBT with Rust engine

Source: https://vectorbt.dev/getting-started/installation

Install VectorBT with the optional Rust engine for performance improvements. This command includes the necessary dependencies.

```bash
pip install -U "vectorbt[rust]"
```

--------------------------------

### Setup Data for Accessors

Source: https://vectorbt.dev/api/generic/accessors

Initializes sample DataFrame and Series objects for use with vectorbt accessors.

```python
>>> import vectorbt as vbt
>>> import numpy as np
>>> import pandas as pd
>>> from numba import njit
>>> from datetime import datetime, timedelta

>>> df = pd.DataFrame({
...     'a': [1, 2, 3, 4, 5],
...     'b': [5, 4, 3, 2, 1],
...     'c': [1, 2, 3, 2, 1]
... }, index=pd.Index([
...     datetime(2020, 1, 1),
...     datetime(2020, 1, 2),
...     datetime(2020, 1, 3),
...     datetime(2020, 1, 4),
...     datetime(2020, 1, 5)
... ]))
>>> df
            a  b  c
2020-01-01  1  5  1
2020-01-02  2  4  2
2020-01-03  3  3  3
2020-01-04  4  2  2
2020-01-05  5  1  1

>>> index = [datetime(2020, 1, 1) + timedelta(days=i) for i in range(10)]
>>> sr = pd.Series(np.arange(len(index)), index=index)
>>> sr
2020-01-01    0
2020-01-02    1
2020-01-03    2
2020-01-04    3
2020-01-05    4
2020-01-06    5
2020-01-07    6
2020-01-08    7
2020-01-09    8
2020-01-10    9
dtype: int64
```

--------------------------------

### ScheduleManager.async_start Method

Source: https://vectorbt.dev/api/utils/schedule_

Starts running pending jobs asynchronously in a loop.

```APIDOC
## ScheduleManager.async_start Method

### Description
Async run pending jobs in a loop.

### Parameters
- **sleep** (int) - The time in seconds to sleep between checking for pending jobs. Defaults to 1.

### Method
`async_start(sleep=1)`
```

--------------------------------

### TelegramBot.start method

Source: https://vectorbt.dev/api/messaging/telegram?q=

Starts the bot. Keyword arguments are passed to the underlying updater.

```python
TelegramBot.start(
    in_background=False,
    **kwargs
)
```

--------------------------------

### Simulate portfolio from orders

Source: https://vectorbt.dev/api/portfolio/base

Examples demonstrating portfolio creation using fixed units and target percentages.

```python
>>> close = pd.Series([1, 2, 3, 4, 5])
>>> pf = vbt.Portfolio.from_orders(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
```

```python
>>> size = [1, 0, -1, 0, 1]
>>> pf = vbt.Portfolio.from_orders(close, size, size_type='targetpercent')

>>> 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
```

```python
>>> np.random.seed(42)
>>> close = pd.DataFrame(np.random.uniform(1, 10, size=(5, 3)))
>>> size = pd.Series(np.full(5, 1/3))  # each column 33.3%
>>> size[1::2] = np.nan  # skip every second tick

>>> pf = vbt.Portfolio.from_orders(
...     close,  # acts both as reference and order price here
...     size,
...     size_type='targetpercent',
...     call_seq='auto',  # first sell then buy
...     group_by=True,  # one group
...     cash_sharing=True,  # assets share the same cash
...     fees=0.001, fixed_fees=1., slippage=0.001  # costs
... )

>>> pf.asset_value(group_by=False).vbt.plot()
```

--------------------------------

### QSAdapter Usage Example

Source: https://vectorbt.dev/api/returns/qs_adapter?q=

Demonstrates how to access quantstats metrics through vectorbt's ReturnsAccessor, showing default parameter handling and direct overrides.

```APIDOC
## QSAdapter Usage Example

### Description
This example illustrates how to use the `QSAdapter` to access `quantstats` metrics via `vectorbt`'s `ReturnsAccessor`. It shows how defaults can be set and overridden.

### Method
N/A (Illustrative Example)

### Endpoint
N/A (Illustrative Example)

### Parameters
N/A

### Request Example
```python
import numpy as np
import pandas as pd
import vectorbt as vbt
import quantstats as qs

np.random.seed(42)
rets = pd.Series(np.random.uniform(-0.1, 0.1, size=(100,)))
benchmark_rets = pd.Series(np.random.uniform(-0.1, 0.1, size=(100,)))

# Using ReturnsAccessor with quantstats adapter
ret_acc = rets.vbt.returns(
    benchmark_rets=benchmark_rets,
    freq='d',
    year_freq='365d',
    defaults=dict(risk_free=0.001)
)

# Accessing a quantstats metric
print(ret_acc.qs.r_squared())
print(ret_acc.qs.sharpe())

# Overriding defaults directly in the adapter
ret_acc_qs = rets.vbt.returns.qs(defaults=dict(benchmark=benchmark_rets, periods=365, periods_per_year=365, rf=0.001))
print(ret_acc_qs.r_squared())
print(ret_acc_qs.sharpe())

# Overriding arguments directly in the function call
print(rets.vbt.returns.qs(defaults=dict(periods=252)).sharpe())
print(rets.vbt.returns.qs.sharpe(periods=252))
```

### Response
#### Success Response (200)
N/A (Illustrative Example)

#### Response Example
```
0.0011582111228735541
-1.9158923252075455
0.0011582111228735541
-1.9158923252075455
-1.5912029345745982
-1.5912029345745982
```
```

--------------------------------

### Simulate portfolio from random signals

Source: https://vectorbt.dev/api/portfolio/base

Examples for testing multiple signal combinations and Cartesian products of probabilities.

```python
>>> close = pd.Series([1, 2, 3, 4, 5])
>>> pf = vbt.Portfolio.from_random_signals(close, n=[2, 1, 0], seed=42)
>>> pf.orders.count()
randnx_n
2    4
1    2
0    0
Name: count, dtype: int64
```

```python
>>> pf = vbt.Portfolio.from_random_signals(
...     close,
...     entry_prob=[0, 0.5, 1],
...     exit_prob=[0, 0.5, 1],
...     param_product=True,
...     seed=42)
>>> pf.orders.count()
rprobnx_entry_prob  rprobnx_exit_prob
0.0                 0.0                  0
                    0.5                  0
                    1.0                  0
0.5                 0.0                  1
                    0.5                  4
                    1.0                  3
1.0                 0.0                  1
                    0.5                  4
                    1.0                  5
Name: count, dtype: int64
```

--------------------------------

### Generic protocol definition example

Source: https://vectorbt.dev/api/generic/accessors?q=

Example of a generic protocol class definition.

```python
class GenProto(Protocol[T]):
    def meth(self) -> T:
        ...
```

--------------------------------

### Initialize and Use Returns Accessors

Source: https://vectorbt.dev/api/returns/accessors?q=

Demonstrates three ways to compute returns and initialize the accessor, followed by a calculation example.

```python
>>> import numpy as np
>>> import pandas as pd
>>> import vectorbt as vbt

>>> 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. vectorbt.generic.accessors.GenericAccessor.to_returns
>>> rets = price.vbt.to_returns()
>>> ret_acc = rets.vbt.returns(freq='d')

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

>>> # vectorbt.returns.accessors.ReturnsAccessor.total
>>> ret_acc.total()
0.0
```

--------------------------------

### SignalsAccessor norm_avg_index Usage Examples

Source: https://vectorbt.dev/api/signals/accessors?q=

Examples demonstrating how norm_avg_index behaves with different signal distributions.

```python
>>> pd.Series([True, False, False, False]).vbt.signals.norm_avg_index()
-1.0

>>> pd.Series([False, False, False, True]).vbt.signals.norm_avg_index()
1.0

>>> pd.Series([True, False, False, True]).vbt.signals.norm_avg_index()
0.0
```

--------------------------------

### Initialize Portfolio and Access Orders

Source: https://vectorbt.dev/api/portfolio/orders?q=

Demonstrates creating a portfolio from order data and accessing the orders object to count buy and sell transactions.

```python
>>> import pandas as pd
>>> import numpy as np
>>> from datetime import datetime, timedelta
>>> import vectorbt as vbt

>>> np.random.seed(42)
>>> price = pd.DataFrame({
...     'a': np.random.uniform(1, 2, size=100),
...     'b': np.random.uniform(1, 2, size=100)
... }, index=[datetime(2020, 1, 1) + timedelta(days=i) for i in range(100)])
>>> size = pd.DataFrame({
...     'a': np.random.uniform(-1, 1, size=100),
...     'b': np.random.uniform(-1, 1, size=100),
... }, index=[datetime(2020, 1, 1) + timedelta(days=i) for i in range(100)])
>>> pf = vbt.Portfolio.from_orders(price, size, fees=0.01, freq='d')
>>> orders = pf.orders

>>> orders.buy.count()
a    58
b    51
Name: count, dtype: int64

>>> orders.sell.count()
a    42
b    49
Name: count, dtype: int64
```

--------------------------------

### Protocol class definition example

Source: https://vectorbt.dev/api/generic/accessors?q=

Example of defining a protocol class for static type checking.

```python
class Proto(Protocol):
    def meth(self) -> int:
        ...
```

--------------------------------

### Create Portfolio from Returns

Source: https://vectorbt.dev/api/returns/qs_adapter?q=

Creates a simulated portfolio from a series of returns. Allows setting the starting balance and rounding options.

```python
QSAdapter.make_portfolio(
    *, 
    start_balance=100000.0,
    mode='comp',
    round_to=None
)
```

--------------------------------

### Configuring QSAdapter Defaults and Overrides

Source: https://vectorbt.dev/api/returns/qs_adapter

Shows how to configure global settings or pass specific overrides to quantstats functions when using the adapter.

```python
vbt.settings.array_wrapper['freq'] = 'h'
vbt.settings.returns['year_freq'] = '365d'

# Using adapter with custom overrides
print(rets.vbt.returns.qs(defaults=dict(periods=252)).sharpe())

# Direct argument override
print(rets.vbt.returns.qs.sharpe(periods=252))
```

--------------------------------

### Usage of GenericSRAccessor.heatmap

Source: https://vectorbt.dev/api/generic/accessors?q=

Examples showing basic heatmap generation and usage with a slider level.

```python
>>> multi_index = pd.MultiIndex.from_tuples([
...     (1, 1),
...     (2, 2),
...     (3, 3)
... ])
>>> sr = pd.Series(np.arange(len(multi_index)), index=multi_index)
>>> sr
1  1    0
2  2    1
3  3    2
dtype: int64

>>> sr.vbt.heatmap()
```

```python
>>> multi_index = pd.MultiIndex.from_tuples([
...     (1, 1, 1),
...     (1, 2, 2),
...     (1, 3, 3),
...     (2, 3, 3),
...     (2, 2, 2),
...     (2, 1, 1)
... ])
>>> sr = pd.Series(np.arange(len(multi_index)), index=multi_index)
>>> sr
1  1  1    0
   2  2    1
   3  3    2
2  3  3    3
   2  2    4
   1  1    5
dtype: int64

>>> sr.vbt.heatmap(slider_level=0)
```

--------------------------------

### Volume Class Initialization

Source: https://vectorbt.dev/api/generic/plotting

Demonstrates the initialization of the Volume class with various parameters.

```APIDOC
## Volume Class Initialization

### Description
Initializes a Volume object for creating 3D volume plots. Accepts data, axis labels, and plotting configuration arguments.

### Method
__init__

### Parameters
#### Args
- **data** (array_like) - Required - Data in any format that can be converted to NumPy. Must be a 3-dim array.
- **x_labels** (array_like) - Optional - X-axis labels.
- **y_labels** (array_like) - Optional - Y-axis labels.
- **z_labels** (array_like) - Optional - Z-axis labels.
- **trace_kwargs** (dict) - Optional - Keyword arguments passed to `plotly.graph_objects.Volume`.
- **add_trace_kwargs** (dict) - Optional - Keyword arguments passed to `add_trace`.
- **scene_name** (str) - Optional - Reference to the 3D scene. Defaults to 'scene'.
- **fig** (Figure or FigureWidget) - Optional - Figure to add traces to.
- **layout_kwargs** - Optional - Keyword arguments for layout.

### Request Example
```python
import vectorbt as vbt
import numpy as np

volume = vbt.plotting.Volume(
    data=np.random.randint(1, 10, size=(3, 3, 3)),
    x_labels=['a', 'b', 'c'],
    y_labels=['d', 'e', 'f'],
    z_labels=['g', 'h', 'i']
)
```

### Response
#### Success Response (200)
Returns the initialized Volume object.

#### Response Example
```python
# The volume object itself is returned upon successful initialization.
# Accessing the figure attribute:
print(volume.fig)
```
```

--------------------------------

### Save and Load Settings

Source: https://vectorbt.dev/api/_settings

Demonstrates persisting settings to disk and updating them in-place.

```python
>>> vbt.settings.save('my_settings')
>>> vbt.settings['caching']['enabled'] = False
>>> vbt.settings['caching']['enabled']
False

>>> vbt.settings.load_update('my_settings')  # load() would return a new object!
>>> vbt.settings['caching']['enabled']
True
```

--------------------------------

### ScheduleManager start Method

Source: https://vectorbt.dev/api/utils/schedule_

Starts the execution of pending jobs in a loop. It takes an optional sleep interval to control the loop's frequency.

```python
ScheduleManager.start(
    sleep=1
)

Run pending jobs in a loop.
```

--------------------------------

### Get Raw Outputs from Indicator

Source: https://vectorbt.dev/api/indicators/factory?q=

Use `return_raw=True` to get raw calculation artifacts. Pass the returned tuple to `use_raw` to reuse these artifacts in subsequent calculations.

```python
>>> raw = vbt.MA.run(price, 2, [False, True], return_raw=True)
>>> raw
([array([[       nan,        nan,        nan,        nan],
         [1.5       , 4.5       , 1.66666667, 4.33333333],
         [2.5       , 3.5       , 2.55555556, 3.44444444],
         [3.5       , 2.5       , 3.51851852, 2.48148148],
         [4.5       , 1.5       , 4.50617284, 1.49382716]])],
 [(2, False), (2, True)],
 2,
 [])
```

```python
>>> vbt.MA.run(price, 2, True, use_raw=raw).ma
ma_window                    2
ma_ewm                    True
                   a         b
2020-01-01       NaN       NaN
2020-01-02  1.666667  4.333333
2020-01-03  2.555556  3.444444
2020-01-04  3.518519  2.481481
2020-01-05  4.506173  1.493827
```

--------------------------------

### Basic Portfolio Creation from Signals

Source: https://vectorbt.dev/api/portfolio/base

Initializes a portfolio using entry and exit signals with specific direction and conflict resolution settings.

```python
>>> pf = vbt.Portfolio.from_signals(
...     close,
...     entries=pd.Series([True, True, True, False, False]),
...     exits=pd.Series([False, False, True, True, True]),
...     size=1,
...     direction='both',
...     upon_opposite_entry='close'
... )
>>> pf.asset_flow()
0    1.0
1    0.0
2    0.0
3   -1.0
4   -1.0
dtype: float64
```

--------------------------------

### Initialize MappedArray

Source: https://vectorbt.dev/api/records/mapped_array?q=

Setup a MappedArray instance using an ArrayWrapper and associated data arrays.

```python
>>> import numpy as np
>>> import pandas as pd
>>> from numba import njit
>>> import vectorbt as vbt

>>> a = np.array([10., 11., 12., 13., 14., 15., 16., 17., 18.])
>>> col_arr = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2])
>>> idx_arr = np.array([0, 1, 2, 0, 1, 2, 0, 1, 2])
>>> wrapper = vbt.ArrayWrapper(index=['x', 'y', 'z'],
...     columns=['a', 'b', 'c'], ndim=2, freq='1 day')
>>> ma = vbt.MappedArray(wrapper, a, col_arr, idx_arr=idx_arr)
```

--------------------------------

### get_multiindex_series

Source: https://vectorbt.dev/api/base/reshape_fns?q=

Gets a Series with a multi-index.

```APIDOC
## get_multiindex_series

### Description
Get Series with a multi-index.
If DataFrame has been passed, should at maximum have one row or column.

### Parameters
* **arg** (array_like) - The input array or DataFrame.
```

--------------------------------

### Initialize portfolio from holding

Source: https://vectorbt.dev/api/portfolio/base

Simulates a portfolio based on holding signals. This method is built upon Portfolio.from_signals().

```python
Portfolio.from_holding(
    close,
    **kwargs
)
```

```python
>>> close = pd.Series([1, 2, 3, 4, 5])
>>> pf = vbt.Portfolio.from_holding(close)
>>> pf.final_value()
500.0
```

--------------------------------

### Import Portfolio Dependencies

Source: https://vectorbt.dev/api/portfolio/base

Initializes the necessary libraries and modules required for portfolio simulation and performance analysis.

```python
>>> import numpy as np
>>> import pandas as pd
>>> from datetime import datetime
>>> import talib
>>> from numba import njit

>>> import vectorbt as vbt
>>> from vectorbt.utils.colors import adjust_opacity
>>> from vectorbt.utils.enum_ import map_enum_fields
>>> from vectorbt.base.reshape_fns import broadcast, flex_select_auto_nb, to_2d_array
>>> from vectorbt.portfolio.enums import SizeType, Direction, NoOrder, OrderStatus, OrderSide
>>> from vectorbt.portfolio import nb
```

--------------------------------

### Using QSAdapter for Quantstats Metrics with Vectorbt

Source: https://vectorbt.dev/api/returns/qs_adapter?q=

Demonstrates how to use the QSAdapter to access quantstats metrics through vectorbt's ReturnsAccessor. It shows how to define benchmark returns and other parameters once and reuse them across multiple quantstats functions. This approach avoids repetitive parameter passing and allows for automatic translation of parameters for quantstats.

```python
import numpy as np
import pandas as pd
import vectorbt as vbt
import quantstats as qs

np.random.seed(42)
rets = pd.Series(np.random.uniform(-0.1, 0.1, size=(100,)))
benchmark_rets = pd.Series(np.random.uniform(-0.1, 0.1, size=(100,)))

# Using QSAdapter via ReturnsAccessor
ret_acc = rets.vbt.returns(
    benchmark_rets=benchmark_rets,
    freq='d',
    year_freq='365d',
    defaults=dict(risk_free=0.001)
)

print(ret_acc.qs.r_squared())
print(ret_acc.qs.sharpe())

# Directly using QSAdapter with quantstats defaults
qs_defaults = dict(
    benchmark=benchmark_rets,
    periods=365,
    periods_per_year=365,
    rf=0.001
)
ret_acc_qs = rets.vbt.returns.qs(defaults=qs_defaults)

print(ret_acc_qs.r_squared())
print(ret_acc_qs.sharpe())

# Overriding arguments
print(rets.vbt.returns.qs(defaults=dict(periods=252)).sharpe())
print(rets.vbt.returns.qs.sharpe(periods=252))
print(qs.stats.sharpe(rets))
```

--------------------------------

### Usage Example for Drawdowns Plotting

Source: https://vectorbt.dev/api/generic/drawdowns?q=

Demonstrates how to initialize Drawdowns from a time series and generate a plot.

```python
>>> 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()
```

--------------------------------

### SignalsAccessor.pos_rank

Source: https://vectorbt.dev/api/signals/accessors?q=

Get signal position ranks.

```APIDOC
## SignalsAccessor.pos_rank(allow_gaps=False, reset_by=None, after_false=False, engine=None, broadcast_kwargs=None, wrap_kwargs=None, as_mapped=False, **kwargs)

### Description
Calculates the position rank of each True value within its partition.

### Parameters
- **allow_gaps** (bool) - Optional - Whether to allow gaps in ranking.
- **reset_by** (any, optional) - Mask or condition to reset ranking.
- **after_false** (bool) - Optional - Whether to rank after a False value.
- **as_mapped** (bool) - Optional - Whether to return a mapped array.
```

--------------------------------

### Accessing Portfolio Logs

Source: https://vectorbt.dev/api/portfolio/logs

Demonstrates how to enable logging during portfolio creation and access the resulting filled, ignored, and rejected order counts.

```python
>>> import pandas as pd
>>> import numpy as np
>>> from datetime import datetime, timedelta
>>> import vectorbt as vbt

>>> np.random.seed(42)
>>> price = pd.DataFrame({
...     'a': np.random.uniform(1, 2, size=100),
...     'b': np.random.uniform(1, 2, size=100)
... }, index=[datetime(2020, 1, 1) + timedelta(days=i) for i in range(100)])
>>> size = pd.DataFrame({
...     'a': np.random.uniform(-100, 100, size=100),
...     'b': np.random.uniform(-100, 100, size=100),
... }, index=[datetime(2020, 1, 1) + timedelta(days=i) for i in range(100)])
>>> pf = vbt.Portfolio.from_orders(price, size, fees=0.01, freq='d', log=True)
>>> logs = pf.logs

>>> logs.filled.count()
a    88
b    99
Name: count, dtype: int64

>>> logs.ignored.count()
a    0
b    0
Name: count, dtype: int64

>>> logs.rejected.count()
a    12
b     1
Name: count, dtype: int64
```

--------------------------------

### QSAdapter Method: best

Source: https://vectorbt.dev/api/returns/qs_adapter?q=

Finds the best period returns using quantstats.stats.best. It supports aggregation and options for compounded returns and return preparation.

```python
def best(
    self,
    *,
    aggregate=None,
    compounded=True,
    prepare_returns=True
):
    """See `quantstats.stats.best`."""
    pass
```

--------------------------------

### Get Ranges

Source: https://vectorbt.dev/api/generic/accessors

Generates range records.

```python
GenericAccessor.get_ranges(
    wrapper_kwargs=None,
    **kwargs
)
```

--------------------------------

### Accessing quantstats via ReturnsAccessor

Source: https://vectorbt.dev/api/returns/qs_adapter

Demonstrates how to use the QSAdapter to calculate statistics like R-squared and Sharpe ratio directly from a ReturnsAccessor object, leveraging vectorbt's automatic parameter handling.

```python
import numpy as np
import pandas as pd
import vectorbt as vbt
import quantstats as qs

np.random.seed(42)
rets = pd.Series(np.random.uniform(-0.1, 0.1, size=(100,)))
benchmark_rets = pd.Series(np.random.uniform(-0.1, 0.1, size=(100,)))

# Direct access via ReturnsAccessor
print(rets.vbt.returns.qs.r_squared(benchmark=benchmark_rets))

# Using defaults for cleaner calls
ret_acc = rets.vbt.returns(
    benchmark_rets=benchmark_rets,
    freq='d',
    year_freq='365d',
    defaults=dict(risk_free=0.001)
)
print(ret_acc.qs.r_squared())
print(ret_acc.qs.sharpe())
```

--------------------------------

### Get Drawdowns

Source: https://vectorbt.dev/api/generic/accessors

Generates drawdown records.

```python
GenericAccessor.get_drawdowns(
    wrapper_kwargs=None,
    **kwargs
)
```

--------------------------------

### SegmentContext.call_seq_now Example

Source: https://vectorbt.dev/api/portfolio/enums?q=

Illustrates the usage of the `call_seq_now` attribute within SegmentContext. This attribute determines the order in which columns within a group are processed. An example `[2, 0, 1]` shows processing column 2 first, then 0, and finally 1.

```python
# Example: [2, 0, 1] would first call column 2, then 0, and finally 1.
```

--------------------------------

### Initialize portfolio from custom order function

Source: https://vectorbt.dev/api/portfolio/base

Constructs a portfolio using a custom order generation function. Refer to simulate_nb() for detailed argument definitions and simulation modes.

```python
Portfolio.from_order_func(
    close,
    order_func_nb,
    *order_args,
    flexible=None,
    init_cash=None,
    cash_sharing=None,
    call_seq=None,
    segment_mask=None,
    call_pre_segment=None,
    call_post_segment=None,
    pre_sim_func_nb=no_pre_func_nb,
    pre_sim_args=(),
    post_sim_func_nb=no_post_func_nb,
    post_sim_args=(),
    pre_group_func_nb=no_pre_func_nb,
    pre_group_args=(),
    post_group_func_nb=no_post_func_nb,
    post_group_args=(),
    pre_row_func_nb=no_pre_func_nb,
    pre_row_args=(),
    post_row_func_nb=no_post_func_nb,
    post_row_args=(),
    pre_segment_func_nb=no_pre_func_nb,
    pre_segment_args=(),
    post_segment_func_nb=no_post_func_nb,
    post_segment_args=(),
    post_order_func_nb=no_post_func_nb,
    post_order_args=(),
    ffill_val_price=None,
    update_value=None,
    fill_pos_record=None,
    init_temp_records=None,
    row_wise=None,
    use_numba=None,
    max_orders=None,
    max_logs=None,
    seed=None,
    group_by=None,
    broadcast_named_args=None,
    broadcast_kwargs=None,
    template_mapping=None,
    wrapper_kwargs=None,
    freq=None,
    attach_call_seq=None,
    **kwargs
)
```

--------------------------------

### get_ranges_arr

Source: https://vectorbt.dev/api/utils/array_

Builds an array from start and end indices.

```APIDOC
## get_ranges_arr

### Description
Builds an array from start and end indices based on stackoverflow.com/a/37626057.

### Parameters
#### Arguments
- **starts** (array) - Required - Start indices
- **ends** (array) - Required - End indices

### Response
- **result** (array) - The constructed range array
```

--------------------------------

### RPROBX Class Constructor

Source: https://vectorbt.dev/api/signals/generators?q=

Initializes RPROBX with wrapper, input/output lists, parameter mappings, and naming conventions. See RPROB for parameter details.

```python
RPROBX(
    wrapper,
    input_list,
    input_mapper,
    in_output_list,
    output_list,
    param_list,
    mapper_list,
    short_name,
    level_names
)
```

--------------------------------

### Portfolio.position_mask

Source: https://vectorbt.dev/api/portfolio/base

Get position mask per column/group.

```APIDOC
## Portfolio.position_mask(direction='both', group_by=None, wrap_kwargs=None)

### Description
Get position mask per column/group. An element is True if the asset is in the market at this tick.
```

--------------------------------

### QSAdapter Method: basic_report

Source: https://vectorbt.dev/api/returns/qs_adapter?q=

Generates a basic performance report using quantstats.reports.basic. This method allows customization of benchmark, risk-free rate, colors, figure size, and compounding, among other options.

```python
def basic_report(
    self,
    *,
    benchmark=None,
    rf=0.0,
    grayscale=False,
    figsize=(8, 5),
    display=True,
    compounded=True,
    periods_per_year=252,
    match_dates=True,
    **kwargs
):
    """See `quantstats.reports.basic`."""
    pass
```

--------------------------------

### Get Time Series Statistics

Source: https://vectorbt.dev/api/signals/generators

Calculates and returns statistics for the `ts` of the indicator in a generic format.

```python
STX.ts_stats(
    *args,
    **kwargs
)

```

--------------------------------

### Portfolio.position_coverage

Source: https://vectorbt.dev/api/portfolio/base

Get position coverage per column/group.

```APIDOC
## Portfolio.position_coverage(direction='both', group_by=None, wrap_kwargs=None)

### Description
Get position coverage per column/group.
```

--------------------------------

### Configure QS Adapter Settings

Source: https://vectorbt.dev/api/_settings

Settings applied across vectorbt.returns.qs_adapter.

```python
Config({
    "defaults": {}
})
```

--------------------------------

### Define Initial Cash Configuration

Source: https://vectorbt.dev/api/portfolio/enums

Examples of setting initial cash based on group structures and cash sharing settings.

```python
# With cash sharing: one group of two columns ($200) and one column ($100)
init_cash_shared = np.array([200, 100])

# Without cash sharing: three columns with $100 each
init_cash_no_share = np.array([100, 100, 100])
```

--------------------------------

### SignalsAccessor.nth_index

Source: https://vectorbt.dev/api/signals/accessors?q=

Get the index of the nth signal occurrence.

```APIDOC
## SignalsAccessor.nth_index(n, return_labels=True, group_by=None, engine=None, wrap_kwargs=None)

### Description
Returns the index of the nth signal occurrence in each column or group.

### Parameters
- **n** (int) - Required - The signal rank to retrieve.
- **return_labels** (bool) - Optional - Whether to return labels.
- **group_by** (any, optional) - Grouping configuration.
- **engine** (str, optional) - Execution engine.
- **wrap_kwargs** (dict, optional) - Keyword arguments for wrapping the result.
```

--------------------------------

### get_return function

Source: https://vectorbt.dev/api/returns/dispatch

Engine-neutral get return calculation.

```APIDOC
## get_return function

### Description
Engine-neutral get return calculation.

### Method
Not applicable (function signature)

### Endpoint
Not applicable (function signature)

### Parameters
- **input_value** (type) - Description
- **output_value** (type) - Description
- **engine** (type) - Optional - Description

### Request Example
```json
{
  "input_value": "...",
  "output_value": "...",
  "engine": null
}
```

### Response
#### Success Response (200)
- **result** (type) - Description of the calculated return

#### Response Example
```json
{
  "result": "..."
}
```
```

--------------------------------

### Create IndicatorFactory with flexible parameter settings

Source: https://vectorbt.dev/api/indicators/factory

Create an IndicatorFactory instance using from_apply_func, specifying flexible broadcasting configurations for parameters like 'window', 'lower', and 'upper'. This allows for efficient memory usage when dealing with numerous parameters.

```python
MyInd = vbt.IndicatorFactory(
    input_names=['price'],
    param_names=['window', 'lower', 'upper'],
    output_names=['output']
).from_apply_func(
    apply_func_nb,
    param_settings=dict(
        window=flex_col_param_config,
        lower=flex_elem_param_config,
        upper=flex_elem_param_config
    ),
    pass_flex_2d=True
)
```

--------------------------------

### ATR Statistics

Source: https://vectorbt.dev/api/indicators/basic

Method to get statistics for ATR.

```APIDOC
## ATR.atr_stats

### Description
Stats of `atr` as generic.

### Method
N/A (Method of a class)

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
Statistical data for ATR.

#### Response Example
None
```

--------------------------------

### is_rust_available function

Source: https://vectorbt.dev/api/_engine?q=

Checks if the `vectorbt-rust` package is installed and version-compatible.

```APIDOC
## is_rust_available function

### Description
Return whether `vectorbt-rust` is installed and version-compatible.

### Method
N/A (Function definition)

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
Boolean indicating Rust availability and compatibility.

#### Response Example
None
```

--------------------------------

### Usage of GenericSRAccessor.qqplot

Source: https://vectorbt.dev/api/generic/accessors?q=

Example of generating a Q-Q plot from a Series.

```python
>>> pd.Series(np.random.standard_normal(100)).vbt.qqplot()
```

--------------------------------

### Create and run custom indicator

Source: https://vectorbt.dev/api/indicators/factory

Instantiate an indicator class using `from_custom_func` and then run it with input data. This example demonstrates setting input, parameter, and output names, and passing additional keyword arguments to the custom function.

```python
>>> MyInd = vbt.IndicatorFactory(
...     input_names=['ts1', 'ts2'],
...     param_names=['p1', 'p2'],
...     output_names=['o1', 'o2']
... ).from_custom_func(custom_func, var_args=True, arg2=200)
```

```python
>>> myInd = MyInd.run(price, price * 2, [1, 2], [3, 4], 100)
```

--------------------------------

### Usage of GenericSRAccessor.plot_against

Source: https://vectorbt.dev/api/generic/accessors?q=

Example of plotting one series against another.

```python
>>> df['a'].vbt.plot_against(df['b'])
```

--------------------------------

### Initialize Records with ArrayWrapper

Source: https://vectorbt.dev/api/records/base?q=

Demonstrates creating a structured numpy array and initializing a Records object with an ArrayWrapper.

```python
>>> import numpy as np
>>> import pandas as pd
>>> from numba import njit
>>> from collections import namedtuple
>>> import vectorbt as vbt

>>> example_dt = np.dtype([
...     ('id', np.int64),
...     ('col', np.int64),
...     ('idx', np.int64),
...     ('some_field', np.float64)
... ])
>>> records_arr = np.array([
...     (0, 0, 0, 10.),
...     (1, 0, 1, 11.),
...     (2, 0, 2, 12.),
...     (3, 1, 0, 13.),
...     (4, 1, 1, 14.),
...     (5, 1, 2, 15.),
...     (6, 2, 0, 16.),
...     (7, 2, 1, 17.),
...     (8, 2, 2, 18.)
... ], dtype=example_dt)
>>> wrapper = vbt.ArrayWrapper(index=['x', 'y', 'z'],
...     columns=['a', 'b', 'c'], ndim=2, freq='1 day')
>>> records = vbt.Records(wrapper, records_arr)
```

--------------------------------

### get_ranges_arr

Source: https://vectorbt.dev/api/utils/array_?q=

Builds an array of indices from start and end points.

```APIDOC
## GET /array/ranges

### Description
Generates an array of indices based on provided start and end points.

### Method
GET

### Endpoint
/array/ranges

### Parameters
#### Query Parameters
- **starts** (array) - Required - Array of starting indices
- **ends** (array) - Required - Array of ending indices

### Request Example
{
  "starts": [0, 5],
  "ends": [2, 7]
}

### Response
#### Success Response (200)
- **result** (array) - The constructed range array

#### Response Example
{
  "result": [0, 1, 5, 6]
}
```

--------------------------------

### Create a simple signal generator with SignalFactory

Source: https://vectorbt.dev/api/signals/factory?q=

Demonstrates building a signal generator using a custom Numba-jitted choice function to determine exit signals.

```python
>>> from numba import njit
>>> from vectorbt.signals.factory import SignalFactory

>>> @njit
... def wait_choice_nb(from_i, to_i, col, n, temp_idx_arr):
...     temp_idx_arr[0] = from_i + n  # index of next exit
...     if temp_idx_arr[0] < to_i:
...         return temp_idx_arr[:1]
...     return temp_idx_arr[:0]  # must return array anyway

>>> # Build signal generator
>>> MySignals = SignalFactory(
...     mode='chain',
...     param_names=['n']
... ).from_choice_func(
...     exit_choice_func=wait_choice_nb,
...     exit_settings=dict(
...         pass_params=['n'],
...         pass_kwargs=['temp_idx_arr']  # built-in kwarg
...     )
... )

>>> # Run signal generator
>>> entries = [True, True, True, True, True]
>>> my_sig = MySignals.run(entries, [0, 1, 2])

>>> my_sig.entries  # input entries
custom_n     0     1     2
0         True  True  True
1         True  True  True
2         True  True  True
3         True  True  True
4         True  True  True

>>> my_sig.new_entries  # output entries
custom_n      0      1      2
0          True   True   True
1         False  False  False
2          True  False  False
3         False   True  False
4          True  False   True

>>> my_sig.exits  # output exits
custom_n      0      1      2
0         False  False  False
1          True  False  False
2          False   True  False
3          True  False   True
4         False  False  False
```

--------------------------------

### TelegramBot.started_callback method

Source: https://vectorbt.dev/api/messaging/telegram?q=

Callback executed once the bot has successfully started.

```python
TelegramBot.started_callback()
```

--------------------------------

### Initialize Logs class

Source: https://vectorbt.dev/api/portfolio/logs

Constructor for the Logs class.

```python
Logs(
    wrapper,
    records_arr,
    col_mapper=None,
    engine=None,
    **kwargs
)
```

--------------------------------

### OHLCSTX Usage Example

Source: https://vectorbt.dev/api/signals/generators?q=

Demonstrates how to use the OHLCSTX class to generate entries and exits based on price data and various stop loss/take profit configurations. Shows how to access properties like entries, exits, stop_price, and stop_type_readable.

```python
import vectorbt as vbt
import pandas as pd
import numpy as np

entries = pd.Series([True, False, False, False, False, False])
price = pd.DataFrame({
    'open': [10, 11, 12, 11, 10, 9],
    'high': [11, 12, 13, 12, 11, 10],
    'low': [9, 10, 11, 10, 9, 8],
    'close': [10, 11, 12, 11, 10, 9]
})
ohlcstx = vbt.OHLCSTX.run(
    entries,
    price['open'], price['high'], price['low'], price['close'],
    sl_stop=[0.1, 0.1, np.nan],
    sl_trail=[False, True, False],
    tp_stop=[np.nan, np.nan, 0.1])

print(ohlcstx.entries)

print(ohlcstx.exits)

print(ohlcstx.stop_price)

print(ohlcstx.stop_type_readable)
```

--------------------------------

### Start and stop TelegramBot

Source: https://vectorbt.dev/api/messaging/telegram

Methods to control the bot lifecycle.

```python
TelegramBot.start(
    in_background=False,
    **kwargs
)
```

```python
TelegramBot.stop()
```

--------------------------------

### SignalsAccessor.partition_pos_rank

Source: https://vectorbt.dev/api/signals/accessors?q=

Get partition position ranks for signal partitions.

```APIDOC
## SignalsAccessor.partition_pos_rank(reset_by=None, after_false=False, engine=None, broadcast_kwargs=None, wrap_kwargs=None, as_mapped=False, **kwargs)

### Description
Calculates the position rank of each partition of True values in the mask.

### Parameters
- **reset_by** (any, optional) - Mask or condition to reset ranking.
- **after_false** (bool) - Optional - Whether to rank after a False value.
- **engine** (str, optional) - Execution engine.
- **as_mapped** (bool) - Optional - Whether to return a mapped array.
```

--------------------------------

### Create Portfolio from Returns

Source: https://vectorbt.dev/api/returns/qs_adapter

Generates a portfolio value series based on initial balance and calculation mode. Useful for converting return streams into equity curves.

```python
QSAdapter.make_portfolio(start_balance=100000.0, mode='comp', round_to=None)
```
Tokens:
Raw