oakscriptpy 0.1.0__py3-none-any.whl

oakscriptpy/__init__.py

@@ -0,0 +1,93 @@
+"""OakScriptPy — PineScript-like API for technical analysis in Python."""
+from __future__ import annotations
+
+# Core namespaces (array-based functions)
+from . import ta as ta_core
+from . import math_ as math
+from . import array
+from . import str_ as str
+from . import color
+from . import time_ as time
+from . import matrix
+
+# Drawing object namespaces
+from . import line
+from . import box
+from . import label
+from . import linefill
+from . import chartpoint as chart_point
+from . import polyline
+
+# Series class (self-contained, no context)
+from .series import Series, BarData
+
+# TA-Series namespace (Series-based wrappers)
+from . import ta_series as ta
+
+# Types
+from ._types import (
+    Bar, Line as LineType, Box as BoxType, Label as LabelType,
+    Linefill as LinefillType, ChartPoint, Polyline as PolylineType,
+    Table, TableCell, Plot, HLine, OHLC, PineMatrix,
+    series_float, series_int, series_bool, series_string,
+    Source, color as color_type, na, xloc,
+)
+
+# Metadata types
+from ._metadata import (
+    PlotOptions, HLineOptions, FillOptions, InputMetadata,
+    PlotMetadata, IndicatorMetadata, TimeValue, PlotData,
+    HLineData, FillData, IndicatorResult,
+)
+
+# Utilities
+from ._utils import is_na, nz, ohlc_from_bars, get_close, get_high, get_low, get_open, get_source
+
+# Runtime
+from .runtime import (
+    set_context, clear_context, get_context,
+    register_calculate, recalculate,
+    plot, hline, clear_plots, get_active_plots,
+)
+from .runtime_types import OakScriptContext, OhlcvData, InputConfig
+
+# Inputs
+from .inputs import (
+    input_int, input_float, input_bool, input_string, input_source,
+    enable_auto_recalculate, disable_auto_recalculate, reset_inputs,
+)
+
+# Indicator infrastructure
+from .indicator import indicator, IndicatorMetadataConfig, IndicatorContext, IndicatorInstance
+
+# Input helper
+from . import input_ as input
+
+# Plot helper
+from .plot_ import plot as plot_helper, create_plot, TimeValuePair, PlotResult
+
+# Adapters
+from .adapters import SimpleInputAdapter
+
+# Libraries
+from .lib import ZigZag, calculate_zigzag
+
+
+def alertcondition(_condition: object = None, _title: str | None = None, _message: str | None = None) -> None:
+    """No-op stub for PineScript alertcondition() compatibility."""
+    pass
+
+
+VERSION = "0.1.0"
+
+info = {
+    "name": "OakScriptPy",
+    "version": VERSION,
+    "description": "PineScript-like API for technical analysis in Python",
+    "namespaces": {
+        "core": ["ta", "math", "array", "str", "color", "time", "matrix"],
+        "drawing": ["line", "box", "label", "linefill", "chart_point", "polyline"],
+        "runtime": ["set_context", "plot", "hline", "input_*"],
+        "indicator": ["indicator", "input", "plot_helper", "create_plot"],
+    },
+}

oakscriptpy/_metadata.py

@@ -0,0 +1,118 @@
+"""Indicator metadata types for oakscriptPy."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+PlotStyle = str  # 'line' | 'stepline' | 'histogram' | 'area' | 'circles' | 'columns' | 'cross' | 'areabr' | 'steplinebr' | 'linebr'
+LineStyle = str  # 'solid' | 'dashed' | 'dotted'
+PlotDisplay = str  # 'all' | 'none' | 'data_window' | 'status_line' | 'pane'
+InputType = str  # 'int' | 'float' | 'bool' | 'string' | 'source' | 'color' | 'timeframe' | 'session'
+
+
+@dataclass
+class PlotOptions:
+    title: str | None = None
+    color: str | None = None
+    linewidth: int | None = None
+    style: str | None = None
+    trackprice: bool | None = None
+    histbase: float | None = None
+    offset: int | None = None
+    join: bool | None = None
+    editable: bool | None = None
+    display: str | None = None
+    transp: int | None = None
+
+
+@dataclass
+class HLineOptions:
+    title: str | None = None
+    color: str | None = None
+    linestyle: str | None = None
+    linewidth: int | None = None
+    editable: bool | None = None
+
+
+@dataclass
+class FillOptions:
+    color: str | None = None
+    transp: int | None = None
+    title: str | None = None
+    editable: bool | None = None
+    fillgaps: bool | None = None
+
+
+@dataclass
+class InputMetadata:
+    type: str
+    name: str
+    title: str
+    defval: Any
+    minval: float | None = None
+    maxval: float | None = None
+    step: float | None = None
+    tooltip: str | None = None
+    inline: str | None = None
+    group: str | None = None
+    options: list[Any] | None = None
+    confirm: bool | None = None
+
+
+@dataclass
+class PlotMetadata:
+    var_name: str
+    title: str
+    color: str
+    linewidth: int
+    style: str
+
+
+@dataclass
+class IndicatorMetadata:
+    title: str
+    shorttitle: str | None = None
+    overlay: bool = False
+    precision: int | None = None
+    format: str | None = None
+    timeframe: str | None = None
+    timeframe_gaps: bool | None = None
+    inputs: list[InputMetadata] | None = None
+    plots: list[PlotMetadata] | None = None
+
+
+@dataclass
+class TimeValue:
+    time: Any
+    value: float
+    color: str | None = None
+
+
+@dataclass
+class PlotData:
+    data: list[TimeValue]
+    options: PlotOptions | None = None
+
+
+@dataclass
+class HLineData:
+    value: float
+    options: HLineOptions | None = None
+
+
+@dataclass
+class FillData:
+    plot1: int | str
+    plot2: int | str
+    options: FillOptions | None = None
+    colors: list[str] | None = None
+
+
+@dataclass
+class IndicatorResult:
+    metadata: IndicatorMetadata
+    plots: dict[str, list[TimeValue]]
+    hlines: list[HLineData] | None = None
+    fills: list[FillData] | None = None

oakscriptpy/_types.py

@@ -0,0 +1,185 @@
+"""Core types for oakscriptPy — mirrors PineScript type system."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Basic type aliases
+series_float = list[float]
+series_int = list[int]
+series_bool = list[bool]
+series_string = list[str]
+series_color = list[str | int]
+Source = list[float]
+color = str | int
+
+# Constants
+na = None
+
+
+class _Xloc:
+    bar_index: str = "bar_index"
+    bar_time: str = "bar_time"
+
+
+xloc = _Xloc()
+
+
+# Drawing objects
+
+@dataclass
+class Line:
+    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
+
+
+@dataclass
+class Box:
+    left: float
+    top: float
+    right: float
+    bottom: float
+    xloc: str = "bar_index"
+    extend: str = "none"
+    border_color: str | int | None = None
+    border_width: int | None = None
+    border_style: str | None = None
+    bgcolor: str | int | None = None
+    text: str | None = None
+    text_size: str | int | None = None
+    text_color: str | int | None = None
+    text_halign: str | None = None
+    text_valign: str | None = None
+    text_wrap: str | None = None
+    text_font_family: str | None = None
+
+
+@dataclass
+class Label:
+    x: float
+    y: float
+    xloc: str = "bar_index"
+    yloc: str = "price"
+    text: str | None = None
+    tooltip: str | None = None
+    color: str | int | None = None
+    style: str | None = None
+    textcolor: str | int | None = None
+    size: str | int | None = None
+    textalign: str | None = None
+    text_font_family: str | None = None
+
+
+@dataclass
+class Linefill:
+    line1: Line
+    line2: Line
+    color: str | int | None = None
+
+
+@dataclass
+class Table:
+    position: str
+    columns: int
+    rows: int
+    frame_color: str | int | None = None
+    frame_width: int | None = None
+    border_color: str | int | None = None
+    border_width: int | None = None
+    bgcolor: str | int | None = None
+    cells: dict[str, TableCell] | None = None
+
+
+@dataclass
+class TableCell:
+    text: str | None = None
+    width: float | None = None
+    height: float | None = None
+    text_color: str | int | None = None
+    text_halign: str | None = None
+    text_valign: str | None = None
+    text_size: str | int | None = None
+    bgcolor: str | int | None = None
+    tooltip: str | None = None
+    text_font_family: str | None = None
+
+
+@dataclass
+class Plot:
+    id: str
+    series: Any = None
+    title: str | None = None
+    color: Any = None
+    linewidth: int | None = None
+    style: str | None = None
+    trackprice: bool | None = None
+    histbase: float | None = None
+    offset: int | None = None
+    join: bool | None = None
+    editable: bool | None = None
+    display: str | None = None
+
+
+@dataclass
+class HLine:
+    id: str
+    price: float
+    title: str | None = None
+    color: Any = None
+    linestyle: str | None = None
+    linewidth: int | None = None
+    editable: bool | None = None
+
+
+@dataclass
+class Bar:
+    time: int
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: float = 0.0
+
+
+@dataclass
+class OHLC:
+    open: list[float]
+    high: list[float]
+    low: list[float]
+    close: list[float]
+
+
+@dataclass
+class ChartPoint:
+    time: float | None
+    index: int | None
+    price: float
+
+
+@dataclass
+class Polyline:
+    id: str
+    points: list[ChartPoint]
+    curved: bool = False
+    closed: bool = False
+    xloc: str = "bar_index"
+    line_color: str | int = "#2962FF"
+    fill_color: str | int | None = None
+    line_style: str = "solid"
+    line_width: int = 1
+    force_overlay: bool = False
+
+
+@dataclass
+class PineMatrix:
+    rows: int
+    columns: int
+    data: list[list[Any]] = field(default_factory=list)

oakscriptpy/_utils.py

@@ -0,0 +1,145 @@
+"""Internal utility functions for oakscriptPy."""
+
+from __future__ import annotations
+
+import math
+import warnings
+from typing import TYPE_CHECKING
+
+from ._types import Bar, OHLC, series_float
+
+if TYPE_CHECKING:
+    from .series import Series
+
+
+def validate_series_length(source: list[float], length: int, function_name: str) -> None:
+    if len(source) < length:
+        warnings.warn(
+            f"{function_name}: Source length ({len(source)}) is less than required length ({length})"
+        )
+
+
+def create_nan_series(length: int) -> series_float:
+    return [float("nan")] * length
+
+
+def is_na(value: object) -> bool:
+    if value is None:
+        return True
+    if isinstance(value, float) and math.isnan(value):
+        return True
+    return False
+
+
+def nz(value: object, default: object = 0) -> object:
+    return default if is_na(value) else value
+
+
+def clamp(value: float, min_val: float, max_val: float) -> float:
+    return max(min_val, min(max_val, value))
+
+
+def lerp(start: float, end: float, t: float) -> float:
+    return start + (end - start) * t
+
+
+def normalize(
+    value: float, min_val: float, max_val: float, new_min: float = 0.0, new_max: float = 1.0
+) -> float:
+    return new_min + ((value - min_val) * (new_max - new_min)) / (max_val - min_val)
+
+
+# Chart data utilities
+
+def ohlc_from_bars(bars: list[Bar]) -> OHLC:
+    return OHLC(
+        open=[b.open for b in bars],
+        high=[b.high for b in bars],
+        low=[b.low for b in bars],
+        close=[b.close for b in bars],
+    )
+
+
+def get_close(ohlc: OHLC) -> series_float:
+    return ohlc.close
+
+
+def get_high(ohlc: OHLC) -> series_float:
+    return ohlc.high
+
+
+def get_low(ohlc: OHLC) -> series_float:
+    return ohlc.low
+
+
+def get_open(ohlc: OHLC) -> series_float:
+    return ohlc.open
+
+
+def get_source(
+    data: list[Bar] | OHLC,
+    source: str = "close",
+) -> series_float:
+    if isinstance(data, OHLC):
+        ohlc = data
+        if source == "close":
+            return ohlc.close
+        if source == "open":
+            return ohlc.open
+        if source == "high":
+            return ohlc.high
+        if source == "low":
+            return ohlc.low
+        if source == "hl2":
+            return [(h + l) / 2 for h, l in zip(ohlc.high, ohlc.low)]
+        if source == "hlc3":
+            return [(h + l + c) / 3 for h, l, c in zip(ohlc.high, ohlc.low, ohlc.close)]
+        if source == "ohlc4":
+            return [
+                (o + h + l + c) / 4
+                for o, h, l, c in zip(ohlc.open, ohlc.high, ohlc.low, ohlc.close)
+            ]
+        if source == "hlcc4":
+            return [
+                (h + l + c + c) / 4 for h, l, c in zip(ohlc.high, ohlc.low, ohlc.close)
+            ]
+    else:
+        bars = data
+        if source == "close":
+            return [b.close for b in bars]
+        if source == "open":
+            return [b.open for b in bars]
+        if source == "high":
+            return [b.high for b in bars]
+        if source == "low":
+            return [b.low for b in bars]
+        if source == "hl2":
+            return [(b.high + b.low) / 2 for b in bars]
+        if source == "hlc3":
+            return [(b.high + b.low + b.close) / 3 for b in bars]
+        if source == "ohlc4":
+            return [(b.open + b.high + b.low + b.close) / 4 for b in bars]
+        if source == "hlcc4":
+            return [(b.high + b.low + b.close + b.close) / 4 for b in bars]
+    return []
+
+
+def shift(series: series_float, offset: int) -> series_float:
+    if offset == 0:
+        return series
+    if offset > 0:
+        return [float("nan")] * offset + series[: -offset]
+    else:
+        return series[-offset:] + [float("nan")] * (-offset)
+
+
+def format_output(
+    values: series_float, timestamps: list[float] | None = None
+) -> list[dict]:
+    result = []
+    for i, value in enumerate(values):
+        result.append({
+            "time": timestamps[i] if timestamps else i,
+            "value": None if math.isnan(value) else value,
+        })
+    return result

oakscriptpy/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Adapter implementations."""
+
+from .simple_input import SimpleInputAdapter
+
+__all__ = ["SimpleInputAdapter"]

oakscriptpy/adapters/simple_input.py

@@ -0,0 +1,63 @@
+"""Simple in-memory input adapter for demos and testing."""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Callable
+
+from ..runtime_types import InputConfig
+
+
+class SimpleInputAdapter:
+    """Stores input configurations and values in memory."""
+
+    def __init__(self) -> None:
+        self._inputs: dict[str, dict[str, Any]] = {}
+        self._change_callbacks: list[Callable[[str, Any], None]] = []
+
+    def register_input(self, config: InputConfig) -> Any:
+        if config.id not in self._inputs:
+            self._inputs[config.id] = {"config": config, "value": config.defval}
+        return self._inputs[config.id]["value"]
+
+    def get_value(self, id: str) -> Any:
+        entry = self._inputs.get(id)
+        return entry["value"] if entry is not None else None
+
+    def set_value(self, id: str, value: Any) -> None:
+        entry = self._inputs.get(id)
+        if entry is None:
+            return
+
+        config: InputConfig = entry["config"]
+        validated = value
+
+        if config.type in ("int", "float") and isinstance(value, (int, float)):
+            if config.min is not None and value < config.min:
+                validated = config.min
+            if config.max is not None and value > config.max:
+                validated = config.max
+            if config.type == "int":
+                validated = int(validated)
+
+        if config.type == "string" and config.options and isinstance(value, str):
+            if value not in config.options:
+                return
+
+        if config.type == "source" and config.options and isinstance(value, str):
+            if value not in config.options:
+                return
+
+        entry["value"] = validated
+        for cb in self._change_callbacks:
+            cb(id, validated)
+
+    def on_input_change(self, callback: Callable[[str, Any], None]) -> None:
+        self._change_callbacks.append(callback)
+
+    def get_all_inputs(self) -> dict[str, dict[str, Any]]:
+        return dict(self._inputs)
+
+    def clear(self) -> None:
+        self._inputs.clear()
+        self._change_callbacks.clear()