Converting from Pine Script

If you have existing Pine Script that you want to use with PyneCore, you have two options:

  1. Manual conversion: Convert your Pine Script code to Pyne code by hand
  2. Automatic conversion: Use the PyneComp compiler (closed source SaaS service) to automatically convert your code. This will be integrated in to the pynecore CLI through API keys.

This guide explains both approaches and highlights the key differences you need to be aware of.

Basic Structure Conversion

Let’s start with the basic structure of a script:

Pine Script:

  //@version=6
indicator("My Indicator", overlay=true)

// Calculations
ma = ta.sma(close, 20)

// Plotting
plot(ma, "SMA", color=color.blue)

PyneCore:

  """
@pyne
"""
from pynecore.lib import script, ta, close, plot, color

@script.indicator("My Indicator", overlay=True)
def main():
    # Calculations
    ma = ta.sma(close, 20)

    # Plotting
    plot(ma, "SMA", color=color.blue)

Key differences:

  1. PyneCore uses a magic comment @pyne instead of //@version=6 (though you could put any metadata after the @pyne comment)
  2. You need to import the required components from the pynecore.lib module
  3. The script declaration is a decorator on the main() function
  4. The main code goes inside the main() function

Variable Declaration Differences

PyneCore uses Python’s type hints for variable declarations:

Pine Script:

  //@version=6
indicator("Variable Example")

// Variable declarations
var float myFloat = 0.0
var int myInt = 0
var bool myBool = true
var string myString = "text"
float[] myArray = array.new_float(0)

PyneCore:

  """
@pyne
"""
from pynecore import Series, Persistent
from pynecore.lib import script, array

@script.indicator("Variable Example")
def main():
    # Variable declarations
    myFloat: Persistent[float] = 0.0  # Note: you don't need to create a Persistent object, just annotate the type
    myInt: Persistent[int] = 0
    myBool: Persistent[bool] = True
    myString: Persistent[str] = "text"
    myArray = array.new_float(0)

Key differences:

  1. var in Pine Script becomes Persistent in PyneCore
  2. PyneCore uses Python’s type hints system (variable: Type = value)
  3. Arrays are handled similarly, but with Python’s syntax

Series Variables

In Pine Script, all variables are series by default. In PyneCore, you need to be explicit:

Pine Script:

  //@version=6
indicator("Series Example")

// All these are series
price = close
avgPrice = ta.sma(price, 20)

PyneCore:

  """
@pyne
"""
from pynecore import Series
from pynecore.lib import script, close, ta

@script.indicator("Series Example")
def main():
    # Need to be explicit about Series types
    price: Series[float] = close
    avgPrice: Series[float] = ta.sma(price, 20)

Function Definitions

Function definitions use Python syntax but behave like Pine Script functions:

Pine Script:

  //@version=6
indicator("Function Example")

// Function definition
myMAFunc(src, len) =>
    result = ta.sma(src, len)
    resultSquared = math.pow(result, 2)
    resultSquared

// Function usage
value = myMAFunc(close, 20)
plot(value)

PyneCore:

  """
@pyne
"""
from pynecore import Series
from pynecore.lib import script, close, ta, plot, math

def myMAFunc(src, len):
    result = ta.sma(src, len)
    resultSquared = math.pow(result, 2)
    return resultSquared  # Explicit return statement

@script.indicator("Function Example")
def main():
    # Function usage
    value = myMAFunc(close, 20)
    plot(value)

Conditional Statements

Conditional statements use Python syntax:

Pine Script:

  //@version=6
indicator("Conditional Example")

// Condition
condition = close > open

// Conditional (ternary) operator
barColor = condition ? color.green : color.red

// If statement
if (condition)
    strategy.entry("Long", strategy.long)
else
    strategy.close("Long")

PyneCore:

  """
@pyne
"""
from pynecore.lib import script, close, open, color, plot, strategy

@script.strategy("Conditional Example")
def main():
    # Condition
    condition = close > open

    # Conditional logic (ternary operator becomes if-else)
    barColor = color.green if condition else color.red

    # If statement
    if condition:
        strategy.entry("Long", strategy.long)
    else:
        strategy.close("Long")

Loops

Loops use Python syntax:

Pine Script:

  //@version=6
indicator("Loop Example")

// For loop
sum = 0.0
for i = 0 to 9
    sum := sum + close[i]
plot(sum / 10)

PyneCore:

  """
@pyne
"""
from pynecore import Series
from pynecore.lib import script, close, plot

@script.indicator("Loop Example")
def main():
    # For loop
    sum = 0.0
    for i in range(10):
        sum += close[i]
    plot(sum / 10)

NA Value Handling

In Pine Script, operations with na values propagate na. In PyneCore, you can use the na() function to check for NA values:

Pine Script:

  //@version=6
indicator("NA Example")

// NA handling
if na(close)
    close := open
value = nz(close, 0)

PyneCore:

  """
@pyne
"""
from pynecore.lib import script, close, open, plot, na, nz

@script.indicator("NA Example")
def main():
    # NA handling
    if na(close):
        close_value = open
    else:
        close_value = close

    value = nz(close, 0)
    plot(value)

Automatic Conversion with PyneComp

For complex scripts, you can use the PyneComp compiler (a closed source SaaS service). This service automatically converts Pine Script code to PyneCore Python code.

Benefits of using PyneComp:

  • Saves time on manual conversion
  • Handles complex syntax and edge cases
  • Generates clean, readable Python code
  • Offers a “strict mode” for better variable scoping

Example: Complete Strategy Conversion

Here’s a more complex strategy conversion example:

Pine Script (RSI Strategy):

  //@version=6
strategy("RSI Strategy", overlay=true)

// Input parameters
length = input.int(14, "RSI Length")
overbought = input.int(70, "Overbought")
oversold = input.int(30, "Oversold")

// Calculate RSI
rsiValue = ta.rsi(close, length)

// Entry/exit conditions
enterLong = ta.crossover(rsiValue, oversold)
exitLong = ta.crossover(rsiValue, overbought)

// Strategy execution
if (enterLong)
    strategy.entry("Long", strategy.long)
else if (exitLong)
    strategy.close("Long")

// Display RSI
hline(overbought, "Overbought", color.red)
hline(oversold, "Oversold", color.green)

PyneCore (RSI Strategy):

  """
@pyne
"""
from pynecore import Series
from pynecore.lib import script, close, ta, strategy, input, hline, color

@script.strategy("RSI Strategy", overlay=True)
def main():
    # Input parameters
    length = input.int("RSI Length", 14)
    overbought = input.int("Overbought", 70)
    oversold = input.int("Oversold", 30)

    # Calculate RSI
    rsiValue: Series[float] = ta.rsi(close, length)

    # Entry/exit conditions
    enterLong = ta.crossover(rsiValue, oversold)
    exitLong = ta.crossover(rsiValue, overbought)

    # Strategy execution
    if enterLong:
        strategy.entry("Long", strategy.long)
    elif exitLong:
        strategy.close("Long")

    # Display RSI
    hline(overbought, "Overbought", color=color.red)
    hline(oversold, "Oversold", color=color.green)

Common Conversion Pitfalls

When converting from Pine Script to PyneCore, be aware of these common issues:

1. Variable Scope and Lifecycle Differences

Both Pine Script and Python use lexical scoping, but with important differences:

Scope differences:

  • Pine Script: Block-level scoping - every code block (if, for, functions) has its own scope
  • Python: Function-level scoping - only functions create new scopes, blocks (if, for) do not

Variable lifecycle differences:

  • Pine Script: By default, variables reinitialize on each bar; use the var keyword to make them persist between bars
  • PyneCore: By default, variables follow normal Python behavior; use Persistent[T] type annotation to indicate persistence between bars

Series behavior:

  • Pine Script: Every variable is a Series by default
  • PyneCore: Series variables must be explicitly marked with Series[T] type annotation

Pine Script example:

  //@version=6
indicator("Scope Example")

// Reinitializes on each bar
counter = 0

// Persists between bars
var persistentCounter = 0

myFunction() =>
    // Only accessible within the function
    localCounter = 0
    
    if (true)
        // Only accessible within the if block
        blockCounter = 42
        localCounter := blockCounter
    
    // blockCounter is NOT accessible outside the if block!
    // blockCounter := 10  // This would cause an error
    
    localCounter  // Return value

Equivalent PyneCore code:

  """
@pyne
"""
from pynecore import Series, Persistent
from pynecore.lib import script

@script.indicator("Scope Example")
def main():
    # Reinitializes on each bar, explicitly marked as Series
    counter: Series[int] = 0
    
    # Persists between bars
    persistentCounter: Persistent[int] = 0
    
    def my_function():
        # Only accessible within the function
        local_counter = 0
        
        if True:
            # DIFFERENCE: block_counter is accessible OUTSIDE the if block in Python!
            block_counter = 42
            local_counter = block_counter
        
        # In Python, block_counter would be usable here
        # block_counter = 10  # This would work in Python (but not in Pine)
        
        return local_counter

The most important difference is that compared to Pine Script’s block-level scoping, Python is less strict, with only functions creating new scopes. Therefore, block-level variables that would be safely encapsulated in Pine Script might have broader scope in Python/PyneCore implementations.

2. Type Handling

PyneCore requires explicit type annotations for Series and Persistent variables.

3. Return Values

In Pine Script, the last expression is automatically the return value. In PyneCore (Python), you need an explicit return statement.

4. Ternary Operators

Pine Script’s ternary operator (condition ? value1 : value2) must be converted to Python’s if-else statements.

5. Reassignment Operator

Pine Script’s := reassignment operator becomes = in Python.

Best Practices for Conversion

  1. Start small: Begin with simple scripts and work your way up
  2. Test thoroughly: Compare results with the original Pine Script
  3. Use type annotations: Be explicit about Series and Persistent variables
  4. Leverage Python features: Take advantage of Python’s richer features during conversion
  5. Keep organized: Break complex scripts into functions or modules