VectorBT PRO

https://vectorbt.pro
Admin
VectorBT PRO is a high-performance engine for backtesting, algorithmic trading, and quantitative...
Tokens:65,883
Snippets:515
Trust Score:7.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Measure library loading time

Source: https://vectorbt.pro/features/productivity

Example of measuring the time taken to import the vectorbtpro library.

```python
>>> start = utc_time()
>>> from vectorbtpro import *
>>> end = utc_time()
>>> end - start
0.580937910079956
```

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

### Define global settings in configuration files

Source: https://vectorbt.pro/features/productivity

Examples of defining global settings using different configuration formats. These files support references to avoid duplicating sensitive credentials.

```ini
[plotting]
default_theme = "dark"

[portfolio]
init_cash = 5000

[data.custom.binance.client_config]
api_key = "<YOUR_API_KEY>"
api_secret = "<YOUR_API_SECRET>"

[data.custom.ccxt.exchanges.binance.exchange_config]
apiKey = &data.custom.binance.client_config.api_key
secret = &data.custom.binance.client_config.api_secret
```

```yaml
plotting:
  default_theme: dark

portfolio:
  init_cash: 5000

data.custom.binance.client_config:
  api_key: &api_key <YOUR_API_KEY>
  api_secret: &api_secret <YOUR_API_SECRET>

data.custom.ccxt.exchanges.binance.exchange_config:
  apiKey: *api_key
  secret: *api_secret
```

```toml
[plotting]
default_theme = "dark"

[portfolio]
init_cash = 5000

[data.custom.binance.client_config]
api_key = "<YOUR_API_KEY>"
api_secret = "<YOUR_API_SECRET>"

[data.custom.ccxt.exchanges.binance.exchange_config]
apiKey = { __vbt_ref__ = "data.custom.binance.client_config.api_key" }
secret = { __vbt_ref__ = "data.custom.binance.client_config.api_secret" }
```

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

### Run Nested Clustered Optimization (NCO)

Source: https://vectorbt.pro/features/optimization

Integrates with Riskfolio-Lib to perform portfolio optimization. This example sets up NCO on a monthly basis using VBT's PFO class and plots the results.

```python
>>> data = vbt.YFData.pull(
...     ["SPY", "TLT", "XLF", "XLE", "XLU", "XLK", "XLB", "XLP", "XLY", "XLI", "XLV"],
...     start="2020",
...     end="2023",
...     missing_index="drop"
... )
>>> pfo = vbt.PFO.from_riskfolio(
...     returns=data.close.vbt.to_returns(),
...     port_cls="hc",
...     every="M"
... )
>>> pfo.plot().show()
```

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

### Import Required Libraries

Source: https://vectorbt.pro/features/overview

Import the necessary libraries for using VBT. This is a prerequisite for running most code examples.

```python
from vectorbtpro import *

```

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

### Run Nested Clustered Optimization (NCO)

Source: https://vectorbt.pro/features/optimization

Use PyPortfolioOpt to perform NCO on a monthly basis. Ensure data is pulled correctly with specified start and end dates.

```python
data = vbt.YFData.pull(
    ["SPY", "TLT", "XLF", "XLE", "XLU", "XLK", "XLB", "XLP", "XLY", "XLI", "XLV"],
    start="2020",
    end="2023",
    missing_index="drop"
)
pfo = vbt.PFO.from_pypfopt(
    returns=data.returns,
    optimizer="hrp",
    target="optimize",
    every="M"
)
pfo.plot().show()
```

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

### Create TA-Lib STOCHRSI Indicator

Source: https://vectorbt.pro/features/indicators

Demonstrates creating a 1D-native STOCHRSI indicator using TA-Lib and vectorbt's Indicator Factory. Ensure TA-Lib is installed.

```python
import talib

params = dict(
    rsi_period=14, 
    fastk_period=5, 
    slowk_period=3, 
    slowk_matype=0, 
    slowd_period=3, 
    slowd_matype=0
)

def stochrsi_1d(close, *args):
    rsi = talib.RSI(close, args[0])
    k, d = talib.STOCH(rsi, rsi, rsi, *args[1:])
    return rsi, k, d

STOCHRSI = vbt.IF(
    input_names=["close"],
    param_names=list(params.keys()),
    output_names=["rsi", "k", "d"]
).with_apply_func(stochrsi_1d, takes_1d=True, **params)

data = vbt.YFData.pull("BTC-USD", start="2022-01", end="2022-06")
stochrsi = STOCHRSI.run(data.close)
fig = stochrsi.k.rename("%K").vbt.plot()
stochrsi.d.rename("%D").vbt.plot(fig=fig)
fig.show()
```

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

### Get Best Bid and Offer (BBO) Data from Databento

Source: https://vectorbt.pro/features/data

Configure Databento client settings with your API key. Then, specify parameters like symbols, dataset, and time range to pull BBO data. Use `get_cost` to estimate the data retrieval cost before pulling.

```python
>>> vbt.BentoData.set_custom_settings(
...     client_config=dict(
...         key="YOUR_KEY"
...     )
... )
>>> params = dict(
...     symbols="ESH3",
...     dataset="GLBX.MDP3",
...     start=vbt.timestamp("2022-10-28 20:30:00"),
...     end=vbt.timestamp("2022-10-28 21:00:00"),
...     schema="tbbo"
... )
>>> vbt.BentoData.get_cost(**params)
1.2002885341644287e-05

>>> data = vbt.BentoData.pull(**params)
>>> data.get()
                                                               ts_event  \
ts_recv                                                                   
2022-10-28 20:30:59.047138053+00:00 2022-10-28 20:30:59.046914657+00:00   
2022-10-28 20:37:53.112494436+00:00 2022-10-28 20:37:53.112246421+00:00   
... 
2022-10-28 20:59:15.075191111+00:00 2022-10-28 20:59:15.074953895+00:00   
2022-10-28 20:59:34.607239899+00:00 2022-10-28 20:59:34.606984277+00:00   

                                     rtype  publisher_id  instrument_id  \
ts_recv                                                                   
2022-10-28 20:30:59.047138053+00:00      1             1         206299   
2022-10-28 20:37:53.112494436+00:00      1             1         206299   
... 
2022-10-28 20:59:15.075191111+00:00      1             1         206299   
2022-10-28 20:59:34.607239899+00:00      1             1         206299   

                                    action side  depth    price  size  flags  \
ts_recv                                                                        
2022-10-28 20:30:59.047138053+00:00      T    B      0  3955.25     1      0   
2022-10-28 20:37:53.112494436+00:00      T    A      0  3955.00     1      0   
... 
2022-10-28 20:59:15.075191111+00:00      T    A      0  3953.75     1      0   
2022-10-28 20:59:34.607239899+00:00      T    A      0  3954.50     2      0   

                                     ts_in_delta  sequence  bid_px_00  \
ts_recv                                                                 
2022-10-28 20:30:59.047138053+00:00        18553  73918214    3954.75   
2022-10-28 20:37:53.112494436+00:00        18334  73926240    3955.00   
... 
2022-10-28 20:59:15.075191111+00:00        19294  73945515    3953.75   
2022-10-28 20:59:34.607239899+00:00        18701  73945932    3954.50   

                                     ask_px_00  bid_sz_00  ask_sz_00  \
ts_recv                                                                
2022-10-28 20:30:59.047138053+00:00    3955.25          1          1   
2022-10-28 20:37:53.112494436+00:00    3955.75          1          1   
... 
2022-10-28 20:59:15.075191111+00:00    3956.00          1          1   
2022-10-28 20:59:34.607239899+00:00    3956.00          4          1   

                                     bid_ct_00  ask_ct_00 symbol  
ts_recv                                                           
2022-10-28 20:30:59.047138053+00:00          1          1   ESH3  
2022-10-28 20:37:53.112494436+00:00          1          1   ESH3  
... 
2022-10-28 20:59:15.075191111+00:00          1          1   ESH3  
2022-10-28 20:59:34.607239899+00:00          3          1   ESH3  


```

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

### Create Rolling Splitter

Source: https://vectorbt.pro/features/optimization

Utilize the Splitter class for robust backtesting by creating rolling windows. This example splits data into training and testing sets with a 360-day window.

```python
>>> data = vbt.YFData.pull("BTC-USD", start="4 years ago")
>>> splitter = vbt.Splitter.from_rolling(
...     data.index, 
...     length="360 days",
...     split=0.5,
...     set_labels=["train", "test"],
...     freq="daily"
... )
>>> splitter.plots().show()
```

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

### Get Cache Statistics Overview

Source: https://vectorbt.pro/features/performance

Retrieves and displays a summary of cache statistics, including hits, misses, and total size, for all enabled cache setups. This is useful for monitoring and optimizing cache usage.

```python
>>> data = vbt.YFData.pull("BTC-USD")
>>> pf = vbt.PF.from_random_signals(data.close, n=5)
>>> _ = pf.stats()

>>> pf.get_ca_setup().get_status_overview(
...     filter_func=lambda setup: setup.caching_enabled,
...     include=["hits", "misses", "total_size"]
... )
                                 hits  misses total_size
object                                                  
portfolio:0.drawdowns               0       1    70.9 kB
portfolio:0.exit_trades             0       1    70.5 kB
portfolio:0.filled_close            6       1    24.3 kB
portfolio:0.init_cash               3       1   32 Bytes
portfolio:0.init_position           0       1   32 Bytes
portfolio:0.init_position_value     0       1   32 Bytes
portfolio:0.init_value              5       1   32 Bytes
portfolio:0.input_value             1       1   32 Bytes
portfolio:0.orders                  9       1    69.7 kB
portfolio:0.total_profit            1       1   32 Bytes
portfolio:0.trades                  0       1    70.5 kB
```

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

### Simulate SMA Strategy on Live Data Stream

Source: https://vectorbt.pro/features/portfolio

Demonstrates using attach_preparer to prepare a portfolio for live data streaming scenarios.

```python
>>> def generate_signals(data):
...     fast_sma = data.run("talib_func:sma", timeperiod=20)
...     slow_sma = data.run("talib_func:sma", timeperiod=50)
...     long_entries = fast_sma.vbt.crossed_above(slow_sma)
...     short_entries = fast_sma.vbt.crossed_below(slow_sma)
...     return long_entries, short_entries

>>> data = vbt.BinanceData.pull(  
...     "BTCUSDT", 
...     start="1 day ago", 
...     end="1 minute ago", 
...     timeframe="1 minute"
... )
>>> long_entries, short_entries = generate_signals(data)
>>> pf = vbt.PF.from_signals(  
...     data, 
...     long_entries=long_entries, 
...     short_entries=short_entries,
...     attach_preparer=True
... )
```

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

### Plot the percentage change from the start of the month to now

Source: https://vectorbt.pro/features/productivity

Uses Numba-compatible datetime functions to calculate percentage changes relative to the start of each month.

```python
>>> @njit
... def month_start_pct_change_nb(arr, index):
...     out = np.full(arr.shape, np.nan)
...     for col in range(arr.shape[1]):
...         for i in range(arr.shape[0]):
...             if i == 0 or vbt.dt_nb.month_nb(index[i - 1]) != vbt.dt_nb.month_nb(index[i]):
...                 month_start_value = arr[i, col]
...             else:
...                 out[i, col] = (arr[i, col] - month_start_value) / month_start_value
...     return out

>>> data = vbt.YFData.pull(["BTC-USD", "ETH-USD"], start="2022", end="2023")
>>> pct_change = month_start_pct_change_nb(
...     vbt.to_2d_array(data.close), 
...     data.index.vbt.to_ns()  
... )
>>> pct_change = data.symbol_wrapper.wrap(pct_change)
>>> pct_change.vbt.plot().show()
```

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

### Get Index of Consumer Sentiment from Nasdaq Data Link

Source: https://vectorbt.pro/features/data

Use the `NDLData` class to pull data from Nasdaq Data Link by providing the dataset ID. The `get()` method retrieves the data as a pandas DataFrame.

```python
>>> data = vbt.NDLData.pull("UMICH/SOC1")
>>> data.get()
                           Index
Date                            
1952-11-30 00:00:00+00:00   86.2
1953-02-28 00:00:00+00:00   90.7
1953-08-31 00:00:00+00:00   80.8
1953-11-30 00:00:00+00:00   80.7
1954-02-28 00:00:00+00:00   82.0
...                          ...
2022-08-31 00:00:00+00:00   58.2
2022-09-30 00:00:00+00:00   58.6
2022-10-31 00:00:00+00:00   59.9
2022-11-30 00:00:00+00:00   56.8
2022-12-31 00:00:00+00:00   59.7

[632 rows x 1 columns]
```

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

### Backtest MACD configurations with vectorbt pro

Source: https://vectorbt.pro/

Demonstrates pulling Binance data, running a parameterized MACD strategy across a large parameter grid, and visualizing win rates.

```python
from vectorbtpro import *

@vbt.parameterized  
@vbt.chunked(chunk_len=1000)  
def pipeline(  
    data: vbt.Param,
    fast: vbt.Chunked,
    slow: vbt.Chunked,
    signal: vbt.Chunked
) -> "concat":
    macd = vbt.talib("MACD").run(data.get("Close"), fast, slow, signal)
    entries = macd.macd_above(0) & macd.macd_above(macd.macdsignal)  
    exits = macd.macd_below(0) | macd.macd_below(macd.macdsignal)  
    pf = vbt.Portfolio.from_signals(data, entries, exits, freq="d")
    return pf.trades.win_rate

data = vbt.BinanceData.pull(["BTCUSDT", "ETHUSDT"])  
param_product = vbt.combine_params(  
    dict(
        fast=np.arange(4, 31),
        slow=np.arange(4, 31),
        signal=np.arange(4, 31)
    ),
    build_index=False
)
win_rates = pipeline(data, **param_product)  
win_rates.vbt.volume(  
    slider_level="symbol",
    trace_kwargs=dict(
        colorscale="icefire", 
        colorbar=dict(title='win_rate', tickformat='.0%'),
        cmid=0.5
    ),
).show()
```

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

### Create Multi-Asset Portfolio from Holding

Source: https://vectorbt.pro/documentation

Initializes a VBT Portfolio from OHLC price DataFrames for multiple assets. Each column in the input DataFrames becomes a separate backtesting instance.

```python
>>> multi_pf = vbt.Portfolio.from_holding(
...     open=multi_open,
...     high=multi_high,
...     low=multi_low,
...     close=multi_close
... )
>>> multi_pf.value
               p1     p2
2020-01-01  100.0  100.0
2020-01-02  150.0   80.0
2020-01-03  200.0   60.0
2020-01-04  250.0   40.0
2020-01-05  300.0   20.0


```

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

### Extract Code from Discord Attachment

Source: https://vectorbt.pro/features/intelligence

Example of a signal function extracted from a Discord message attachment.

```python
@njit
def signal_func_nb(c, entries, exits, wait):
    is_entry = vbt.pf_nb.select_nb(c, entries)
    if is_entry:
        return True, False, False, False
    is_exit = vbt.pf_nb.select_nb(c, exits)
    if is_exit:
        if vbt.pf_nb.in_position_nb(c):
            last_order = vbt.pf_nb.get_last_order_nb(c)
            if c.index[c.i] - c.index[last_order["idx"]] >= wait:
                return False, True, False, False
    return False, False, False, False

pf = vbt.PF.from_random_signals(
    "BTC-USD",
    n=100,
    signal_func_nb=signal_func_nb,
    signal_args=(
        vbt.Rep("entries"),
        vbt.Rep("exits"),
        vbt.dt.to_ns(vbt.timedelta("1000 days"))
    )
)
```

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

### Optimize Portfolio Weights

Source: https://vectorbt.pro/features/portfolio

Demonstrates pulling market data, generating random signals, optimizing weights with PyPortfolioOpt, and applying them to a portfolio.

```python
>>> data = vbt.YFData.pull(["AAPL", "MSFT", "GOOG"], start="2020")
>>> pf = data.run("from_random_signals", n=vbt.Default(50), seed=42, group_by=True)
>>> pf.get_sharpe_ratio(group_by=False)  
symbol
AAPL    1.401012
MSFT    0.456162
GOOG    0.852490
Name: sharpe_ratio, dtype: float64

>>> pf.sharpe_ratio  
1.2132857343006869

>>> prices = pf.get_value(group_by=False)
>>> weights = vbt.pypfopt_optimize(prices=prices)  
>>> weights
{'AAPL': 0.85232, 'MSFT': 0.0, 'GOOG': 0.14768}

>>> weighted_pf = pf.apply_weights(weights, rescale=True)  
>>> weighted_pf.weights
symbol
AAPL    2.55696
MSFT    0.00000
GOOG    0.44304
dtype: float64

>>> weighted_pf.get_sharpe_ratio(group_by=True)  
1.426112580298898
```

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

### Chat with VBT using ChatGPT

Source: https://vectorbt.pro/features/intelligence

Initializes environment variables and uses the chat interface to query the knowledge base.

```python
>>> env["GITHUB_TOKEN"] = "<YOUR_GITHUB_TOKEN>"
>>> env["OPENAI_API_KEY"] = "<YOUR_OPENAI_API_KEY>"

>>> vbt.chat("How to rebalance weekly?", formatter="html")
```

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

### Create OHLC DataFrame

Source: https://vectorbt.pro/documentation/fundamentals

Example of creating a Pandas DataFrame with OHLC data for a single asset. This DataFrame serves as input for VBT.

```python
p1 = pd.DataFrame({
    'open': [1, 2, 3, 4, 5],
    'high': [2.5, 3.5, 4.5, 5.5, 6.5],
    'low': [0.5, 1.5, 2.5, 3.5, 4.5],
    'close': [2, 3, 4, 5, 6]
}, index=vbt.date_range("2020-01-01", periods=5))

```

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

### Manage MCP server and tools

Source: https://vectorbt.pro/features/productivity

Launch the MCP server or invoke registered tools directly from the terminal.

```bash
vbt mcp serve  

vbt mcp search "VBTWarning: Object has multiple columns?"  

vbt mcp search --call '{"kwargs": {"query": "VBTWarning: Object has multiple columns?"}}'
```

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

### Create OHLC DataFrame for Multiple Assets

Source: https://vectorbt.pro/documentation/fundamentals

Example of creating a Pandas DataFrame with OHLC data for a second asset. This will be used to demonstrate multi-asset backtesting.

```python
p2 = pd.DataFrame({
    'open': [6, 5, 4, 3, 2],
    'high': [6.5, 5.5, 4.5, 3.5, 2.5],
    'low': [4.5, 3.5, 2.5, 1.5, 0.5],
    'close': [5, 4, 3, 2, 1]
}, index=vbt.date_range("2020-01-01", periods=5))

```

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

### Perform Mean-Variance Optimization with SL and TP in Python

Source: https://vectorbt.pro/features/portfolio

Shows how to convert target allocations from riskfolio into signals with integrated stop-loss and take-profit functionality.

```python
>>> data = vbt.YFData.pull(
...     ["SPY", "TLT", "XLF", "XLE", "XLU", "XLK", "XLB", "XLP", "XLY", "XLI", "XLV"],
...     start="2022",
...     end="2023",
...     missing_index="drop"
... )
>>> pfo = vbt.PFO.from_riskfolio(data.returns, every="M")
>>> pf = pfo.simulate(
...     data, 
...     pf_method="from_signals", 
...     sl_stop=0.05,
...     tp_stop=0.1, 
...     stop_exit_price="close"  
... )
>>> pf.plot_allocations().show()
```

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

### Verify settings loading

Source: https://vectorbt.pro/features/productivity

Check that the configuration settings have been correctly applied to the vbt.settings object.

```python
>>> from vectorbtpro import *

>>> vbt.settings.portfolio["init_cash"]
5000
```

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

### Execute Signals with Rust Backend

Source: https://vectorbt.pro/features/productivity

Demonstrates using the Rust backend for rolling mean calculations and portfolio signal generation.

```python
>>> data = vbt.YFData.pull("BTC-USD", start="2024")

>>> fast_ma = data.close.vbt.rolling_mean(20)  
>>> slow_ma = data.close.vbt.rolling_mean(50)
>>> entries = fast_ma.vbt.crossed_above(slow_ma)  
>>> exits = fast_ma.vbt.crossed_below(slow_ma)

>>> pf = vbt.Portfolio.from_signals(  
...     data,
...     entries=entries,
...     exits=exits,
...     sl_stop=0.05,
...     tp_stop=0.15,
...     fees=0.001,
... )
```

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

### Save and Read Minute Data with DuckDB

Source: https://vectorbt.pro/features/data

Store minute-level data in a DuckDB database and retrieve a specific day's data. Ensure DuckDB is installed and accessible.

```python
>>> data = vbt.TVData.pull(
...     "AAPL",
...     exchange="NASDAQ",
...     timeframe="1 minute",
...     tz="America/New_York"
... )

>>> URL = "database.duckdb"
>>> data.to_duckdb(connection=URL)

>>> day_data = vbt.DuckDBData.pull(
...     "AAPL",
...     start="2023-10-02 09:30:00",
...     end="2023-10-02 16:00:00",
...     tz="America/New_York",
...     connection=URL
... )
>>> day_data.get()
                              Open    High     Low   Close    Volume
datetime
2023-10-02 09:30:00-04:00  171.260  171.34  170.93  171.10   61654.0
2023-10-02 09:31:00-04:00  171.130  172.37  171.13  172.30   53481.0
2023-10-02 09:32:00-04:00  172.310  172.64  172.16  172.64   44750.0
2023-10-02 09:33:00-04:00  172.640  172.97  172.54  172.78   53195.0
2023-10-02 09:34:00-04:00  172.780  173.07  172.75  173.00   47416.0
...                            ...     ...     ...     ...       ...
2023-10-02 15:55:00-04:00  173.300  173.51  173.26  173.51   61619.0
2023-10-02 15:56:00-04:00  173.525  173.59  173.42  173.43   45066.0
2023-10-02 15:57:00-04:00  173.430  173.55  173.42  173.50   45220.0
2023-10-02 15:58:00-04:00  173.510  173.60  173.46  173.56   47371.0
2023-10-02 15:59:00-04:00  173.560  173.78  173.56  173.75  161253.0

[390 rows x 5 columns]
```

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

### Create Single Portfolio from Holding

Source: https://vectorbt.pro/documentation

Initializes a VBT Portfolio from individual OHLC price Series for a single asset. This is the recommended way to input data into VBT.

```python
>>> single_pf = vbt.Portfolio.from_holding(
...     open=p1['open'], 
...     high=p1['high'], 
...     low=p1['low'], 
...     close=p1['close']
... )
>>> single_pf.value
2020-01-01    100.0
2020-01-02    150.0
2020-01-03    200.0
2020-01-04    250.0
2020-01-05    300.0
Freq: D, dtype: float64


```

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

### Get Stochastic RSI from Alpha Vantage

Source: https://vectorbt.pro/features/data

Use the `AVData` class to pull technical indicators like Stochastic RSI from Alpha Vantage. Specify the category, function, and any necessary parameters.

```python
>>> data = vbt.AVData.pull(
...     "IBM",
...     category="technical-indicators",
...     function="STOCHRSI",
...     params=dict(fastkperiod=14)
... )
>>> data.get()
                              FastD     FastK
1999-12-07 00:00:00+00:00  100.0000  100.0000
1999-12-08 00:00:00+00:00  100.0000  100.0000
1999-12-09 00:00:00+00:00   77.0255   31.0765
1999-12-10 00:00:00+00:00   43.6922    0.0000
1999-12-13 00:00:00+00:00   12.0197    4.9826
...                             ...       ...
2023-01-26 00:00:00+00:00   11.7960    0.0000
2023-01-27 00:00:00+00:00    3.7773    0.0000
2023-01-30 00:00:00+00:00    4.4824   13.4471
2023-01-31 00:00:00+00:00    7.8258   10.0302
2023-02-01 16:00:01+00:00   13.0966   15.8126

[5826 rows x 2 columns]
```

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

### Simulate Limit Orders with Random Signals

Source: https://vectorbt.pro/features/portfolio

Demonstrates how to use limit orders in a signal-based simulation and visualize the impact of limit delta on order count.

```python
>>> pf = vbt.PF.from_random_signals(
...     vbt.YFData.pull("BTC-USD"), 
...     n=100, 
...     order_type="limit", 
...     limit_delta=vbt.Param(np.arange(0.001, 0.1, 0.001)),  
... )
>>> pf.orders.count().vbt.plot(
...     xaxis_title="Limit delta", 
...     yaxis_title="Order count"
... ).show()
```

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

### Pull Tick Data with FinDataPy

Source: https://vectorbt.pro/features/data

Pulls one day of tick data for EURUSD from Dukascopy using FinDataPy. This example demonstrates fetching specific tick data with default fields.

```python
>>> data = vbt.FinPyData.pull(  
...     "fx.dukascopy.tick.NYC.EURUSD",
...     start="14 Jun 2016",
...     end="15 Jun 2016"
... )
>>> data.get()
                                     close
Date                                      
2016-06-14 00:00:00.844000+00:00  1.128795
2016-06-14 00:00:01.591000+00:00  1.128790
2016-06-14 00:00:01.743000+00:00  1.128775
2016-06-14 00:00:02.464000+00:00  1.128770
2016-06-14 00:00:02.971000+00:00  1.128760
...                                    ...
2016-06-14 23:59:57.733000+00:00  1.121020
2016-06-14 23:59:58.239000+00:00  1.121030
2016-06-14 23:59:58.953000+00:00  1.121035
2016-06-14 23:59:59.004000+00:00  1.121050
2016-06-14 23:59:59.934000+00:00  1.121055

[82484 rows x 1 columns]
```

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

### Run WorldQuant Alpha 1

Source: https://vectorbt.pro/features/indicators

Demonstrates how to run the first WorldQuant Alpha (WQA1) as a vectorbt indicator. This allows for easy integration and analysis of pre-defined quantitative factors.

```python
data = vbt.YFData.pull(["BTC-USD", "ETH-USD", "XRP-USD"], missing_index="drop")

vbt.wqa101(1).run(data.close).out
```

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

### Explore leverage effects on equity curve

Source: https://vectorbt.pro/features/portfolio

Uses vbt.Param to simulate a portfolio with varying leverage levels and plots the resulting equity curves.

```python
>>> data = vbt.YFData.pull("BTC-USD", start="2020", end="2022")
>>> pf = vbt.PF.from_random_signals(
...     data, 
...     n=100,  
...     leverage=vbt.Param([0.5, 1, 2, 3]),
... )
>>> pf.value.vbt.plot().show()
```

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

### Interact with VBT via CLI

Source: https://vectorbt.pro/features/productivity

Use the CLI to ask questions, perform quick lexical searches, or interact with MCP tools.

```bash
vbt chat "How to backtest a weekly rebalancing strategy?"
```

```bash
vbt quick-chat "What does size_type='target_percent' do?"
```

```bash
vbt interact "Plot the equity curve for a 10/30 SMA crossover on BTC-USD"
```

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

### Get a prepared argument, modify it, and use in a new simulation

Source: https://vectorbt.pro/features/portfolio

Demonstrates how to extract and modify simulation arguments using the preparer pipeline. The modified arguments can be passed back into the simulation via target_func or by replacing the prep_result.

```python
>>> data = vbt.YFData.pull("BTC-USD", end="2017-01")
>>> prep_result = vbt.PF.from_holding(
...     data, 
...     stop_ladder="uniform",
...     tp_stop=vbt.Param([
...         [0.1, 0.2, 0.3, 0.4, 0.5],
...         [0.4, 0.5, 0.6],
...     ], keys=["tp_ladder_1", "tp_ladder_2"]),
...     return_prep_result=True  
... )
>>> prep_result.target_args["tp_stop"]  
array([[0.1, 0.4],
       [0.2, 0.5],
       [0.3, 0.6],
       [0.4, nan],
       [0.5, nan]])

>>> new_tp_stop = prep_result.target_args["tp_stop"] + 0.1
>>> new_prep_result = prep_result.replace(target_args=dict(tp_stop=new_tp_stop), nested_=True)  
>>> new_prep_result.target_args["tp_stop"]
array([[0.2, 0.5],
       [0.3, 0.6],
       [0.4, 0.7],
       [0.5, nan],
       [0.6, nan]])

>>> pf = vbt.PF.from_signals(new_prep_result)  
>>> pf.total_return
tp_stop
tp_ladder_1    0.4
tp_ladder_2    0.6
Name: total_return, dtype: float64

>>> sim_out = new_prep_result.target_func(**new_prep_result.target_args)  
>>> pf = vbt.PF(sim_out=sim_out, **new_prep_result.pf_args)
>>> pf.total_return
tp_stop
tp_ladder_1    0.4
tp_ladder_2    0.6
Name: total_return, dtype: float64
```

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

### Parameterize Bollinger Bands Pipeline

Source: https://vectorbt.pro/features/optimization

Parameterize an entire Bollinger Bands pipeline using the @vbt.parameterized decorator. This example demonstrates parameterizing multiple inputs for a complex strategy and uses 'concat' for merging scalar and Series metrics.

```python
>>> @vbt.parameterized(merge_func="concat")  
... def bbands_sharpe(data, timeperiod=14, nbdevup=2, nbdevdn=2, thup=0.3, thdn=0.1):
...     bb = data.run(
...         "talib_bbands", 
...         timeperiod=timeperiod, 
...         nbdevup=nbdevup, 
...         nbdevdn=nbdevdn
...     )
...     bandwidth = (bb.upperband - bb.lowerband) / bb.middleband
...     cond1 = data.low < bb.lowerband
...     cond2 = bandwidth > thup
...     cond3 = data.high > bb.upperband
...     cond4 = bandwidth < thdn
...     entries = (cond1 & cond2) | (cond3 & cond4)
...     exits = (cond1 & cond4) | (cond3 & cond2)
...     pf = vbt.PF.from_signals(data, entries, exits)
...     return pf.sharpe_ratio

>>> bbands_sharpe(
...     vbt.YFData.pull("BTC-USD"),
...     nbdevup=vbt.Param([1, 2]),  
...     nbdevdn=vbt.Param([1, 2]),
...     thup=vbt.Param([0.4, 0.5]),
...     thdn=vbt.Param([0.1, 0.2])
... )
```

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

### Compute net exposure with cached components

Source: https://vectorbt.pro/features/portfolio

Demonstrates how to manually compute net exposure by caching intermediate long and short exposure components, which helps avoid redundant calculations.

```python
>>> data = vbt.YFData.pull("BTC-USD")
>>> pf = vbt.PF.from_random_signals(data.close, n=100)
>>> value = pf.get_value()  
>>> long_exposure = vbt.PF.get_gross_exposure(  
...     asset_value=pf.get_asset_value(direction="longonly"),
...     value=value,
...     wrapper=pf.wrapper
... )
>>> short_exposure = vbt.PF.get_gross_exposure(
...     asset_value=pf.get_asset_value(direction="shortonly"),
...     value=value,
...     wrapper=pf.wrapper
... )
>>> del value  
>>> net_exposure = vbt.PF.get_net_exposure(
...     long_exposure=long_exposure,
...     short_exposure=short_exposure,
...     wrapper=pf.wrapper
... )
>>> del long_exposure
>>> del short_exposure
>>> net_exposure
Date
2014-09-17 00:00:00+00:00    1.0
2014-09-18 00:00:00+00:00    1.0
2014-09-19 00:00:00+00:00    1.0
2014-09-20 00:00:00+00:00    1.0
2014-09-21 00:00:00+00:00    1.0
                             ... 
2023-02-08 00:00:00+00:00    0.0
2023-02-09 00:00:00+00:00    0.0
2023-02-10 00:00:00+00:00    0.0
2023-02-11 00:00:00+00:00    0.0
2023-02-12 00:00:00+00:00    0.0
Freq: D, Length: 3071, dtype: float64
```

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

### Simulate Online Minimum-Variance Portfolio

Source: https://vectorbt.pro/features/optimization

Utilize Universal Portfolios to simulate an online minimum-variance portfolio on a weekly time frame. Configure parameters like window size and history minimum.

```python
data = vbt.YFData.pull(
    ["SPY", "TLT", "XLF", "XLE", "XLU", "XLK", "XLB", "XLP", "XLY", "XLI", "XLV"],
    start="2020",
    end="2023",
    missing_index="drop"
)
pfo = vbt.PFO.from_universal_algo(
    "MPT",
    data.resample("W").close,
    window=52,
    min_history=4,
    mu_estimator='historical',
    cov_estimator='empirical',
    method='mpt',
    q=0
)
pfo.plot().show()
```

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

### Get Trade History DataFrame

Source: https://vectorbt.pro/features/analysis

Retrieves the detailed trade history for a random portfolio. Useful for human-readable analysis of orders, entries, exits, and positions. Requires specifying data and optionally trade parameters like take-profit and stop-loss.

```python
>>> data = vbt.YFData.pull(["BTC-USD", "ETH-USD"], missing_index="drop")
>>> pf = vbt.PF.from_random_signals(
...     data, 
...     n=1,
...     run_kwargs=dict(hide_params=True),
...     tp_stop=0.5, 
...     sl_stop=0.1
... )
>>> pf.trade_history
```

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

### Merge and Process BTC Data from Multiple Exchanges

Source: https://vectorbt.pro/features/data

Combine BTC data from different exchanges (Binance, Bybit, Bitfinex, KuCoin) into a single DataFrame using `vbt.Data.merge`. The example also demonstrates renaming symbols and applying custom transformations and rolling means.

```python
>>> binance_data = vbt.CCXTData.pull("BTCUSDT", exchange="binance")
>>> bybit_data = vbt.CCXTData.pull("BTCUSDT", exchange="bybit")
>>> bitfinex_data = vbt.CCXTData.pull("BTC/USDT", exchange="bitfinex")
>>> kucoin_data = vbt.CCXTData.pull("BTC-USDT", exchange="kucoin")

>>> data = vbt.Data.merge([
...     binance_data.rename({"BTCUSDT": "Binance"}),
...     bybit_data.rename({"BTCUSDT": "Bybit"}),
...     bitfinex_data.rename({"BTC/USDT": "Bitfinex"}),
...     kucoin_data.rename({"BTC-USDT": "KuCoin"}),
... ], missing_index="drop", silence_warnings=True)

>>> @njit
... def rescale_nb(x):
...     return (x - x.mean()) / x.mean()

>>> rescaled_close = data.close.vbt.row_apply(rescale_nb)
>>> rescaled_close = rescaled_close.vbt.rolling_mean(30)
>>> rescaled_close.loc["2023":"2023"].vbt.plot().show()
```

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

### Benchmark portfolio performance with pre-computation

Source: https://vectorbt.pro/features/portfolio

Compares performance when pre-computing returns versus calculating them on the fly.

```python
%%timeit
pf = vbt.PF.from_random_signals(data, n=np.arange(1000).tolist(), save_returns=False)
pf.sharpe_ratio
```

```python
%%timeit
pf = vbt.PF.from_random_signals(data, n=np.arange(1000).tolist(), save_returns=True)
pf.sharpe_ratio
```

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

### Detect Sudden Changes in Bollinger Bands

Source: https://vectorbt.pro/features/indicators

Utilize the SIGDET indicator to identify sudden changes or outbreaks in the bandwidth of a Bollinger Bands indicator. This is effective for detecting outliers or significant shifts in market volatility. The example visualizes Bollinger Bands and the detected signals over a specific period.

```python
>>> data = vbt.YFData.pull("BTC-USD")
>>> fig = vbt.make_subplots(rows=2, cols=1, shared_xaxes=True)
>>> bbands = data.run("bbands")
>>> bbands.loc["2022"].plot(add_trace_kwargs=dict(row=1, col=1), fig=fig)
>>> sigdet = vbt.SIGDET.run(bbands.bandwidth, factor=5)
>>> sigdet.loc["2022"].plot(add_trace_kwargs=dict(row=2, col=1), fig=fig)
>>> fig.show()
```

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

### Plot Confirmed Pivot Points

Source: https://vectorbt.pro/features/indicators

Visualize confirmed pivot points (peaks and valleys) identified by the pivot detection indicator. This indicator filters out short-term fluctuations and only returns confirmed trend reversals, making it safe for backtesting. The example plots pivot information alongside price data.

```python
>>> data = vbt.YFData.pull("BTC-USD", start="2020", end="2023")
>>> fig = data.plot(plot_volume=False)
>>> pivot_info = data.run("pivotinfo", up_th=1.0, down_th=0.5)
>>> pivot_info.plot(fig=fig, conf_value_trace_kwargs=dict(visible=False))
>>> fig.show()
```

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

### Determine Spread Between BTC and ETH using Rolling OLS

Source: https://vectorbt.pro/features/indicators

Analyze the relationship between two time series using Rolling Ordinary Least Squares (OLS). This indicator returns slope, intercept, prediction, error, and z-score at each time step. It's particularly useful for cointegration tests and pairs trading. The example calculates and plots the z-score of the spread between BTC and ETH closing prices.

```python
>>> data = vbt.YFData.pull(
...     ["BTC-USD", "ETH-USD"], 
...     start="2022", 
...     end="2023",
...     missing_index="drop"
... )
>>> ols = vbt.OLS.run(
...     data.get("Close", "BTC-USD"), 
...     data.get("Close", "ETH-USD")
... )
>>> ols.plot_zscore().show()
```
Tokens:
Raw