How to convert Pine Script to Python (pandas) without changing the signals
Porting a TradingView script to Python is mostly easy. The hard part is getting exactly the same values on every bar, so your Python backtest or bot agrees with the chart. Here is the checklist we use.
1. Map Pine series to pandas columns
Every Pine variable is a series: one value per bar. In Python, load bars into a DataFrame with a time index and one column per field (open, high, low, close, volume). Then:
| Pine | pandas |
|---|---|
close[1] | df["close"].shift(1) |
ta.sma(close, 20) | df["close"].rolling(20).mean() |
ta.highest(high, 10) | df["high"].rolling(10).max() |
ta.change(close) | df["close"].diff() |
na / nz(x) | NaN / x.fillna(0) |
ta.crossover(a, b) | (a > b) & (a.shift(1) <= b.shift(1)) |
ta.crossunder(a, b) | (a < b) & (a.shift(1) >= b.shift(1)) |
2. Watch the smoothing functions
This is where most ports drift. Pine's ta.rma (used inside ta.rsi and ta.atr) is Wilder smoothing with alpha = 1/length, and it starts from a simple average of the first length values. pandas ewm(alpha=1/length, adjust=False) starts from the first value instead, so the early bars differ, and RSI can stay off by a few tenths for a long time on short histories.
The fix is a small loop that seeds with the SMA, then applies the recursive formula:
def pine_rma(x, length):
alpha = 1.0 / length
out = [float("nan")] * len(x)
vals = list(x)
for i in range(length - 1, len(vals)):
if i == length - 1:
out[i] = sum(vals[:length]) / length
else:
out[i] = alpha * vals[i] + (1 - alpha) * out[i - 1]
return out
(This sketch assumes no leading NaNs; a full version skips them first.) Do the same check for ta.ema (alpha = 2/(length+1)): compare the first 50 bars against values exported from TradingView before trusting it.
3. Keep var state and bar-by-bar logic honest
var variables keep their value from bar to bar. Vectorised pandas code can't always express that. When a script updates state conditionally (trailing stops, "in position" flags), write a plain for loop over rows. It's slower but matches Pine's execution model.
4. Avoid lookahead bias
- By default, a Pine strategy decides on the bar close and fills at the next bar's open. In Python, compute the signal on bar t and fill at
openof bar t+1. request.security()with higher timeframes can leak future data. Only use a higher-timeframe value after that higher-timeframe bar has closed.- Never use
df.shift(-1)in signal code.
5. Prove it with a test
Export a few hundred bars plus the indicator values from TradingView (chart → "Export chart data"), then write a pytest that compares your Python output column-by-column with a small tolerance. Once it passes, your port is done.
Want to see a complete example? Our free worked example converts an RSI + signal + bands script with tests.
Prefer to hand it off?
We convert your Pine Script to clean, tested Python (pandas). Simple scripts $29, standard strategies $79. After checkout you email the script and get back code, tests and notes on anything that can't be reproduced exactly.
Conversions are code only. Not financial advice, and no claim that any strategy is profitable. Not affiliated with TradingView.
