PyneCore

PyneCore is an open-source framework that implements the TradingView Pine Script bar-by-bar execution model natively in Python. It allows developers to write trading strategies and technical indicators using Python syntax while benefiting from Pine Script's intuitive semantics.

Key characteristics include:

• AST Transformation: Instead of using heavy object-oriented wrappers, PyneCore uses Python's Abstract Syntax Tree (AST) to transform regular Python code into Pine Script-like behavior.
• High Compatibility: Aims for 0.001% precision tolerance compared to TradingView's Pine Script.
• Zero Mandatory Dependencies: The core system is designed to operate without external libraries for maximum portability.
• Pythonic Integration: Maintains Python's type hints, ecosystem, and syntax while providing specialized trading primitives.

The PyneCore CLI manages OHLCV (Open, High, Low, Close, Volume) data through the pyne data subcommand. It supports downloading historical data from various providers, converting between PyneCore's efficient binary .ohlcv format and common formats like CSV or JSON, and aggregating data across timeframes.

Available commands under pyne data:

• download: Fetch historical OHLCV data from a provider.
• convert-to: Convert PyneCore .ohlcv files to CSV or JSON.
• convert-from: Convert CSV or JSON files into PyneCore .ohlcv format.
• aggregate: Aggregate data from a lower to a higher timeframe.

pyne data [COMMAND] [OPTIONS] [ARGUMENTS]

PyneCore can be used directly from Python code to embed Pine Script indicators and strategies into external applications. This allows for integration into trading bots, custom backtesting frameworks, data pipelines, and other automated systems, moving beyond the standalone CLI usage.

Key programmatic capabilities include:

• ScriptRunner API: Running scripts from Python and accessing the resulting indicator or strategy data.
• Visual Output (Viz): Configuring plot styles and exporting drawing data as an opt-in NDJSON stream.
• Data & SymInfo: Loading or creating OHLCV (Open, High, Low, Close, Volume) data and symbol information.
• Integration Patterns: Implementing real-world workflows such as FreqTrade integration, live trading, or custom system builds.

The pynecore.lib.text namespace provides constants used to control the visual presentation of text within drawing objects like labels, boxes, and table cells. You can use these constants to specify horizontal/vertical alignment, text styles (bold/italic), and wrapping behavior.

from pynecore.lib import script, label, text, bar_index, high, low, close, ta

@script.indicator(title="Signal Labels", overlay=True)
def main():
    is_cross: bool = ta.crossover(close, ta.sma(close, 20))
    if is_cross:
        label.new(
            bar_index, high,
            text="BUY",
            textalign=text.align_center,
            style=label.style_label_up,
            text_formatting=text.format_bold
        )

The pynecore.lib.math namespace provides mathematical functions and constants for use in indicators and strategies. All functions handle NA (not available) values gracefully: if any input is NA, the function returns NA.

from pynecore.lib import math, close, script

@script.indicator(title="Math Demo", overlay=True)
def main():
    # Example usage
    val = math.abs(close - close[1])

The Pyne ecosystem provides a complete solution for achieving TradingView Pine Script compatibility within a Python environment. It is composed of two primary pillars:

1. PyneCore (Open Source): The foundational Python library that implements a Pine Script-like runtime. It provides the execution model, AST transformations for Pine-like syntax, technical indicators, series data structures, and backtesting capabilities.
2. PyneComp (SaaS Service): A compiler/transpiler that converts existing Pine Script code into clean, readable PyneCore-compatible Python code. This allows for a smooth migration from TradingView to Python.

PyneComp can be accessed via the PyneSys API, the pynesys.io web interface, or directly through the PyneCore CLI (requires an API key).

The PyneCore reference documentation is organized into four primary sections to help you understand the script structure, type system, input handling, and the core library:

• Script Format: Explains the required anatomy of a @pyne script, including magic comments, imports, decorators, the main() function, and input parameters.
• Types: Details the PyneCore type system, covering primitives, collections, drawing types, and specialized annotations like Series, Persistent, IBPersistent, @udt, and StrEnum.
• Input Functions: Provides documentation for user-configurable script parameters (e.g., input.int(), input.float(), input.string()) and how to manage them via TOML-based configuration.
• Library: A comprehensive reference for all library functions, variables, and constants, organized by namespaces such as ta, math, and strategy.

The pynecore.lib.color namespace provides tools for creating, modifying, and inspecting colors used in visual elements like lines, labels, and plots. You can use predefined color constants, create custom colors via RGB or hex strings, apply transparency, and generate color gradients based on data ranges.

from pynecore.lib import color, Color

# Use predefined colors
my_color: Color = color.green

# Create custom color with transparency
transparent_blue: Color = color.new(color.blue, transp=50)

# Create color from RGB values
custom_color: Color = color.rgb(255, 165, 0)

# Create color gradient based on price position
price_position: float = (close - low) / (high - low) if high != low else 0.5
bar_color: Color = color.from_gradient(
    price_position, 0, 1, color.red, color.green
)