oakscriptpy 0.1.0__py3-none-any.whl

oakscriptpy/indicator.py

@@ -0,0 +1,82 @@
+"""Indicator factory — creates reusable indicator instances."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from ._types import Bar
+
+
+@dataclass
+class IndicatorMetadataConfig:
+    title: str
+    short_title: str | None = None
+    overlay: bool = False
+    format: str = "price"
+    precision: int = 2
+
+
+@dataclass
+class IndicatorContext:
+    data: list[Bar]
+    open: list[float]
+    high: list[float]
+    low: list[float]
+    close: list[float]
+    volume: list[float]
+    time: list[int]
+    pane_index: int = 0
+
+
+class IndicatorInstance:
+    def __init__(self, metadata: IndicatorMetadataConfig, setup: Callable[[IndicatorContext], None]) -> None:
+        self.metadata = metadata
+        self._setup = setup
+        self._pane_index = 0 if metadata.overlay else 1
+        self._input_values: dict[str, Any] = {}
+
+    @property
+    def pane_index(self) -> int:
+        return self._pane_index
+
+    def is_overlay(self) -> bool:
+        return self.metadata.overlay
+
+    def update_inputs(self, inputs: dict[str, Any]) -> None:
+        self._input_values.update(inputs)
+
+    def get_input_values(self) -> dict[str, Any]:
+        return dict(self._input_values)
+
+    def calculate(self, data: list[Bar]) -> None:
+        ctx = IndicatorContext(
+            data=data,
+            open=[b.open for b in data],
+            high=[b.high for b in data],
+            low=[b.low for b in data],
+            close=[b.close for b in data],
+            volume=[b.volume for b in data],
+            time=[b.time for b in data],
+            pane_index=self._pane_index,
+        )
+        self._setup(ctx)
+
+
+def indicator(
+    metadata: IndicatorMetadataConfig,
+    setup: Callable[[IndicatorContext], None],
+) -> Callable[[], IndicatorInstance]:
+    """Create an indicator factory function."""
+    normalized = IndicatorMetadataConfig(
+        title=metadata.title,
+        short_title=metadata.short_title or metadata.title,
+        overlay=metadata.overlay,
+        format=metadata.format,
+        precision=metadata.precision,
+    )
+
+    def factory() -> IndicatorInstance:
+        return IndicatorInstance(normalized, setup)
+
+    return factory

oakscriptpy/input_.py

@@ -0,0 +1,38 @@
+"""Input helper — creates InputValue dataclass instances."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class InputValue:
+    type: str
+    default_value: Any
+    value: Any
+    title: str | None = None
+    min: float | None = None
+    max: float | None = None
+    step: float | None = None
+    options: list[str] | None = None
+
+
+def int_(default_value: int, title: str | None = None, min: int | None = None, max: int | None = None, step: int = 1) -> InputValue:
+    return InputValue(type="int", default_value=default_value, value=default_value, title=title, min=float(min) if min is not None else None, max=float(max) if max is not None else None, step=float(step))
+
+
+def float_(default_value: float, title: str | None = None, min: float | None = None, max: float | None = None, step: float = 0.1) -> InputValue:
+    return InputValue(type="float", default_value=default_value, value=default_value, title=title, min=min, max=max, step=step)
+
+
+def source(default_value: str = "close", title: str | None = None) -> InputValue:
+    return InputValue(type="source", default_value=default_value, value=default_value, title=title, options=["open", "high", "low", "close", "hl2", "hlc3", "ohlc4", "hlcc4"])
+
+
+def bool_(default_value: bool, title: str | None = None) -> InputValue:
+    return InputValue(type="bool", default_value=default_value, value=default_value, title=title)
+
+
+def string(default_value: str, title: str | None = None, options: list[str] | None = None) -> InputValue:
+    return InputValue(type="string", default_value=default_value, value=default_value, title=title, options=options)

oakscriptpy/inputs.py

@@ -0,0 +1,170 @@
+"""Input functions — mirrors PineScript input.* with idempotent semantics."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from .runtime import get_context, recalculate
+from .runtime_types import InputConfig
+
+_registered_inputs: dict[str, bool] = {}
+_auto_recalculate_enabled: bool = False
+_input_counter: int = 0
+
+
+def enable_auto_recalculate() -> None:
+    global _auto_recalculate_enabled
+    _auto_recalculate_enabled = True
+
+
+def disable_auto_recalculate() -> None:
+    global _auto_recalculate_enabled
+    _auto_recalculate_enabled = False
+
+
+def reset_inputs() -> None:
+    global _input_counter
+    _registered_inputs.clear()
+    _input_counter = 0
+
+
+def _generate_input_id(title: str | None, defval: Any, type_: str) -> str:
+    global _input_counter
+    if title:
+        return title.replace(" ", "_")
+    id_ = f"{type_}_{_input_counter}_{defval}"
+    _input_counter += 1
+    return id_
+
+
+def input_int(
+    defval: int, title: str | None = None,
+    min: int | None = None, max: int | None = None, step: int = 1,
+) -> int:
+    ctx = get_context()
+    if ctx is None:
+        return int(defval)
+
+    id_ = _generate_input_id(title, defval, "int")
+    config = InputConfig(
+        id=id_, type="int", defval=int(defval), title=title,
+        min=float(min) if min is not None else None,
+        max=float(max) if max is not None else None,
+        step=float(step),
+    )
+
+    if id_ not in _registered_inputs:
+        ctx.inputs.register_input(config)
+        _registered_inputs[id_] = True
+        if _auto_recalculate_enabled:
+            ctx.inputs.on_input_change(lambda cid, _v: recalculate() if cid == id_ else None)
+
+    value = ctx.inputs.get_value(id_)
+    return int(value) if isinstance(value, (int, float)) else int(defval)
+
+
+def input_float(
+    defval: float, title: str | None = None,
+    min: float | None = None, max: float | None = None, step: float = 0.1,
+) -> float:
+    ctx = get_context()
+    if ctx is None:
+        return defval
+
+    id_ = _generate_input_id(title, defval, "float")
+    config = InputConfig(
+        id=id_, type="float", defval=defval, title=title,
+        min=min, max=max, step=step,
+    )
+
+    if id_ not in _registered_inputs:
+        ctx.inputs.register_input(config)
+        _registered_inputs[id_] = True
+        if _auto_recalculate_enabled:
+            ctx.inputs.on_input_change(lambda cid, _v: recalculate() if cid == id_ else None)
+
+    value = ctx.inputs.get_value(id_)
+    return float(value) if isinstance(value, (int, float)) else defval
+
+
+def input_bool(defval: bool, title: str | None = None) -> bool:
+    ctx = get_context()
+    if ctx is None:
+        return defval
+
+    id_ = _generate_input_id(title, defval, "bool")
+    config = InputConfig(id=id_, type="bool", defval=defval, title=title)
+
+    if id_ not in _registered_inputs:
+        ctx.inputs.register_input(config)
+        _registered_inputs[id_] = True
+        if _auto_recalculate_enabled:
+            ctx.inputs.on_input_change(lambda cid, _v: recalculate() if cid == id_ else None)
+
+    value = ctx.inputs.get_value(id_)
+    return bool(value) if isinstance(value, bool) else defval
+
+
+def input_string(
+    defval: str, title: str | None = None, options: list[str] | None = None,
+) -> str:
+    ctx = get_context()
+    if ctx is None:
+        return defval
+
+    id_ = _generate_input_id(title, defval, "string")
+    config = InputConfig(id=id_, type="string", defval=defval, title=title, options=options)
+
+    if id_ not in _registered_inputs:
+        ctx.inputs.register_input(config)
+        _registered_inputs[id_] = True
+        if _auto_recalculate_enabled:
+            ctx.inputs.on_input_change(lambda cid, _v: recalculate() if cid == id_ else None)
+
+    value = ctx.inputs.get_value(id_)
+    return str(value) if isinstance(value, str) else defval
+
+
+def input_source(defval: str = "close", title: str | None = None) -> list[float]:
+    ctx = get_context()
+    if ctx is None:
+        return []
+
+    id_ = _generate_input_id(title, defval, "source")
+    config = InputConfig(
+        id=id_, type="source", defval=defval, title=title,
+        options=["open", "high", "low", "close", "volume", "hl2", "hlc3", "ohlc4"],
+    )
+
+    if id_ not in _registered_inputs:
+        ctx.inputs.register_input(config)
+        _registered_inputs[id_] = True
+        if _auto_recalculate_enabled:
+            ctx.inputs.on_input_change(lambda cid, _v: recalculate() if cid == id_ else None)
+
+    source_name = ctx.inputs.get_value(id_)
+    if not isinstance(source_name, str):
+        source_name = defval
+
+    return _get_source_data(ctx.ohlcv, source_name)
+
+
+def _get_source_data(ohlcv: Any, source_name: str) -> list[float]:
+    if source_name == "open":
+        return ohlcv.open
+    if source_name == "high":
+        return ohlcv.high
+    if source_name == "low":
+        return ohlcv.low
+    if source_name == "close":
+        return ohlcv.close
+    if source_name == "volume":
+        return ohlcv.volume
+    if source_name == "hl2":
+        return [(h + l) / 2 for h, l in zip(ohlcv.high, ohlcv.low)]
+    if source_name == "hlc3":
+        return [(h + l + c) / 3 for h, l, c in zip(ohlcv.high, ohlcv.low, ohlcv.close)]
+    if source_name == "ohlc4":
+        return [(o + h + l + c) / 4 for o, h, l, c in zip(ohlcv.open, ohlcv.high, ohlcv.low, ohlcv.close)]
+    return ohlcv.close

oakscriptpy/label.py

@@ -0,0 +1,110 @@
+"""Label namespace — mirrors PineScript label.* functions."""
+
+from __future__ import annotations
+
+import copy as _copy
+
+from ._types import Label
+
+
+def new(
+    x: float, y: float, text: str | None = None,
+    xloc: str = "bar_index", yloc: str = "price",
+    color: str | int | None = None, style: str | None = None,
+    textcolor: str | int | None = None, size: str | int | None = None,
+    textalign: str | None = None, tooltip: str | None = None,
+    text_font_family: str | None = None,
+) -> Label:
+    return Label(
+        x=x, y=y, xloc=xloc, yloc=yloc, text=text, tooltip=tooltip,
+        color=color, style=style, textcolor=textcolor, size=size,
+        textalign=textalign, text_font_family=text_font_family,
+    )
+
+
+def get_x(id: Label) -> float:
+    return id.x
+
+
+def get_y(id: Label) -> float:
+    return id.y
+
+
+def get_text(id: Label) -> str | None:
+    return id.text
+
+
+def copy(id: Label) -> Label:
+    return _copy.copy(id)
+
+
+def set_x(id: Label, x: float) -> Label:
+    id.x = x
+    return id
+
+
+def set_y(id: Label, y: float) -> Label:
+    id.y = y
+    return id
+
+
+def set_xy(id: Label, x: float, y: float) -> Label:
+    id.x = x
+    id.y = y
+    return id
+
+
+def set_xloc(id: Label, x: float, xloc: str) -> Label:
+    id.x = x
+    id.xloc = xloc
+    return id
+
+
+def set_yloc(id: Label, y: float, yloc: str) -> Label:
+    id.y = y
+    id.yloc = yloc
+    return id
+
+
+def set_text(id: Label, text: str) -> Label:
+    id.text = text
+    return id
+
+
+def set_tooltip(id: Label, tooltip: str) -> Label:
+    id.tooltip = tooltip
+    return id
+
+
+def set_color(id: Label, color: str | int) -> Label:
+    id.color = color
+    return id
+
+
+def set_textcolor(id: Label, color: str | int) -> Label:
+    id.textcolor = color
+    return id
+
+
+def set_style(id: Label, style: str) -> Label:
+    id.style = style
+    return id
+
+
+def set_size(id: Label, size: str | int) -> Label:
+    id.size = size
+    return id
+
+
+def set_textalign(id: Label, align: str) -> Label:
+    id.textalign = align
+    return id
+
+
+def set_text_font_family(id: Label, font: str) -> Label:
+    id.text_font_family = font
+    return id
+
+
+def delete(id: Label) -> None:
+    pass

oakscriptpy/lib/__init__.py

@@ -0,0 +1,5 @@
+"""Libraries."""
+
+from .zigzag import ZigZag, calculate_zigzag
+
+__all__ = ["ZigZag", "calculate_zigzag"]

oakscriptpy/lib/zigzag.py

@@ -0,0 +1,158 @@
+"""ZigZag library — identifies trend reversals via pivot highs and lows."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .._types import Bar
+
+
+@dataclass
+class ZigZagSettings:
+    dev_threshold: float = 5.0
+    depth: int = 10
+    line_color: str = "#2962FF"
+    extend_last: bool = True
+    display_reversal_price: bool = True
+    display_cumulative_volume: bool = True
+    display_reversal_price_change: bool = True
+    difference_price_mode: str = "Absolute"
+    allow_zigzag_on_one_bar: bool = True
+
+
+@dataclass
+class ZigZagPoint:
+    time: int
+    bar_index: int
+    price: float
+
+
+@dataclass
+class ZigZagPivot:
+    is_high: bool
+    volume: float
+    start: ZigZagPoint
+    end: ZigZagPoint
+
+
+@dataclass
+class ZigZagResult:
+    pivots: list[ZigZagPivot]
+    extension: ZigZagPivot | None
+
+
+class ZigZag:
+    def __init__(self, settings: ZigZagSettings | None = None) -> None:
+        self.settings = settings or ZigZagSettings()
+        self.pivots: list[ZigZagPivot] = []
+        self.sum_vol: float = 0.0
+        self._high_buffer: list[float] = []
+        self._low_buffer: list[float] = []
+        self._time_buffer: list[int] = []
+        self._bar_count: int = 0
+
+    def update(self, bar: Bar, bar_index: int) -> bool:
+        self._high_buffer.append(bar.high)
+        self._low_buffer.append(bar.low)
+        self._time_buffer.append(bar.time)
+        self._bar_count += 1
+
+        depth = max(2, self.settings.depth // 2)
+        self.sum_vol += bar.volume
+
+        if self._bar_count < depth * 2 + 1:
+            return False
+
+        changed = self._try_find_pivot(True, depth, bar_index)
+        changed = self._try_find_pivot(
+            False, depth, bar_index,
+            self.settings.allow_zigzag_on_one_bar or not changed,
+        ) or changed
+        return changed
+
+    def last_pivot(self) -> ZigZagPivot | None:
+        return self.pivots[-1] if self.pivots else None
+
+    def get_extension(self, current_bar: Bar, bar_index: int) -> ZigZagPivot | None:
+        if not self.settings.extend_last:
+            return None
+        last = self.last_pivot()
+        if last is None:
+            return None
+        is_high = not last.is_high
+        price = current_bar.high if is_high else current_bar.low
+        return ZigZagPivot(
+            is_high=is_high, volume=self.sum_vol,
+            start=last.end, end=ZigZagPoint(time=current_bar.time, bar_index=bar_index, price=price),
+        )
+
+    def _try_find_pivot(self, is_high: bool, depth: int, current_bar_index: int, register: bool = True) -> bool:
+        point = self._find_pivot_point(is_high, depth, current_bar_index)
+        if point is None or not register:
+            return False
+        return self._new_pivot_found(is_high, point)
+
+    def _find_pivot_point(self, is_high: bool, depth: int, current_bar_index: int) -> ZigZagPoint | None:
+        buffer = self._high_buffer if is_high else self._low_buffer
+        pivot_idx = len(buffer) - 1 - depth
+        if pivot_idx < depth:
+            return None
+        pivot_price = buffer[pivot_idx]
+
+        for i in range(pivot_idx + 1, len(buffer)):
+            p = buffer[i]
+            if is_high and p > pivot_price:
+                return None
+            if not is_high and p < pivot_price:
+                return None
+
+        for i in range(pivot_idx - depth, pivot_idx):
+            p = buffer[i]
+            if is_high and p >= pivot_price:
+                return None
+            if not is_high and p <= pivot_price:
+                return None
+
+        return ZigZagPoint(
+            time=self._time_buffer[pivot_idx],
+            bar_index=current_bar_index - depth,
+            price=pivot_price,
+        )
+
+    def _calc_dev(self, base_price: float, price: float) -> float:
+        return 100 * (price - base_price) / abs(base_price) if base_price != 0 else 0.0
+
+    def _new_pivot_found(self, is_high: bool, point: ZigZagPoint) -> bool:
+        last = self.last_pivot()
+        if last is None:
+            self.pivots.append(ZigZagPivot(is_high=is_high, volume=self.sum_vol, start=point, end=point))
+            self.sum_vol = 0.0
+            return True
+
+        if last.is_high == is_high:
+            more_extreme = (point.price > last.end.price) if is_high else (point.price < last.end.price)
+            if more_extreme:
+                last.end = point
+                last.volume += self.sum_vol
+                self.sum_vol = 0.0
+                return True
+        else:
+            dev = self._calc_dev(last.end.price, point.price)
+            threshold = self.settings.dev_threshold
+            meets = (dev <= -threshold) if last.is_high else (dev >= threshold)
+            if meets:
+                self.pivots.append(ZigZagPivot(is_high=is_high, volume=self.sum_vol, start=last.end, end=point))
+                self.sum_vol = 0.0
+                return True
+        return False
+
+
+def calculate_zigzag(bars: list[Bar], settings: ZigZagSettings | None = None) -> ZigZagResult:
+    if not bars:
+        return ZigZagResult(pivots=[], extension=None)
+    zz = ZigZag(settings)
+    for i, bar in enumerate(bars):
+        zz.update(bar, i)
+    extension = zz.get_extension(bars[-1], len(bars) - 1)
+    return ZigZagResult(pivots=zz.pivots, extension=extension)

oakscriptpy/line.py

@@ -0,0 +1,120 @@
+"""Line namespace — mirrors PineScript line.* functions."""
+
+from __future__ import annotations
+
+import copy as _copy
+
+from ._types import Line
+
+
+def new(
+    x1: float, y1: float, x2: float, y2: float,
+    xloc: str = "bar_index", extend: str = "none",
+    color: str | int | None = None, style: str | None = None, width: int | None = None,
+) -> Line:
+    return Line(x1=x1, y1=y1, x2=x2, y2=y2, xloc=xloc, extend=extend,
+                color=color, style=style or "solid", width=width or 1)
+
+
+def get_price(id: Line, x: float) -> float:
+    if id.xloc == "bar_time":
+        raise ValueError("line.get_price() only works with xloc.bar_index lines")
+    if id.x2 == id.x1:
+        return float("nan")
+    slope = (id.y2 - id.y1) / (id.x2 - id.x1)
+    price = id.y1 + slope * (x - id.x1)
+    lo = min(id.x1, id.x2)
+    hi = max(id.x1, id.x2)
+    if id.extend == "none":
+        if x < lo or x > hi:
+            return float("nan")
+    elif id.extend == "left":
+        if x > hi:
+            return float("nan")
+    elif id.extend == "right":
+        if x < lo:
+            return float("nan")
+    return price
+
+
+def get_x1(id: Line) -> float:
+    return id.x1
+
+
+def get_x2(id: Line) -> float:
+    return id.x2
+
+
+def get_y1(id: Line) -> float:
+    return id.y1
+
+
+def get_y2(id: Line) -> float:
+    return id.y2
+
+
+def copy(id: Line) -> Line:
+    return _copy.copy(id)
+
+
+def set_x1(id: Line, x: float) -> Line:
+    id.x1 = x
+    return id
+
+
+def set_x2(id: Line, x: float) -> Line:
+    id.x2 = x
+    return id
+
+
+def set_y1(id: Line, y: float) -> Line:
+    id.y1 = y
+    return id
+
+
+def set_y2(id: Line, y: float) -> Line:
+    id.y2 = y
+    return id
+
+
+def set_xy1(id: Line, x: float, y: float) -> Line:
+    id.x1 = x
+    id.y1 = y
+    return id
+
+
+def set_xy2(id: Line, x: float, y: float) -> Line:
+    id.x2 = x
+    id.y2 = y
+    return id
+
+
+def set_xloc(id: Line, x1: float, x2: float, xloc: str) -> Line:
+    id.x1 = x1
+    id.x2 = x2
+    id.xloc = xloc
+    return id
+
+
+def set_extend(id: Line, extend: str) -> Line:
+    id.extend = extend
+    return id
+
+
+def set_color(id: Line, color: str | int) -> Line:
+    id.color = color
+    return id
+
+
+def set_style(id: Line, style: str) -> Line:
+    id.style = style
+    return id
+
+
+def set_width(id: Line, width: int) -> Line:
+    id.width = width
+    return id
+
+
+def delete(id: Line) -> None:
+    pass

oakscriptpy/linefill.py

@@ -0,0 +1,26 @@
+"""Linefill namespace — mirrors PineScript linefill.* functions."""
+
+from __future__ import annotations
+
+from ._types import Linefill, Line
+
+
+def new(line1: Line, line2: Line, color: str | int | None = None) -> Linefill:
+    return Linefill(line1=line1, line2=line2, color=color)
+
+
+def get_line1(id: Linefill) -> Line:
+    return id.line1
+
+
+def get_line2(id: Linefill) -> Line:
+    return id.line2
+
+
+def set_color(id: Linefill, color: str | int) -> Linefill:
+    id.color = color
+    return id
+
+
+def delete(id: Linefill) -> None:
+    pass