oakscriptpy 0.1.0__py3-none-any.whl

oakscriptpy/array.py

@@ -0,0 +1,342 @@
+"""Array namespace — mirrors PineScript array.* functions."""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def new_array(size: int = 0, initial_value: Any = None) -> list:
+    return [initial_value] * size
+
+
+def size(id: list) -> int:
+    return len(id)
+
+
+def get(id: list, index: int) -> Any:
+    return id[index]
+
+
+def set(id: list, index: int, value: Any) -> None:
+    id[index] = value
+
+
+def push(id: list, value: Any) -> None:
+    id.append(value)
+
+
+def pop(id: list) -> Any:
+    return id.pop()
+
+
+def unshift(id: list, value: Any) -> None:
+    id.insert(0, value)
+
+
+def shift(id: list) -> Any:
+    return id.pop(0)
+
+
+def clear(id: list) -> None:
+    id.clear()
+
+
+def insert(id: list, index: int, value: Any) -> None:
+    id.insert(index, value)
+
+
+def remove(id: list, index: int) -> Any:
+    return id.pop(index)
+
+
+def includes(id: list, value: Any) -> bool:
+    return value in id
+
+
+def indexof(id: list, value: Any) -> int:
+    try:
+        return id.index(value)
+    except ValueError:
+        return -1
+
+
+def lastindexof(id: list, value: Any) -> int:
+    for i in range(len(id) - 1, -1, -1):
+        if id[i] == value:
+            return i
+    return -1
+
+
+def copy(id: list) -> list:
+    return id[:]
+
+
+def concat(id1: list, id2: list) -> list:
+    return id1 + id2
+
+
+def join(id: list, separator: str = ",") -> str:
+    return separator.join(str(x) for x in id)
+
+
+def reverse(id: list) -> None:
+    id.reverse()
+
+
+def slice(id: list, index_from: int, index_to: int | None = None) -> list:
+    return id[index_from:index_to]
+
+
+def sort(id: list, order: str = "asc") -> None:
+    id.sort(reverse=(order == "desc"))
+
+
+def sum(id: list[float]) -> float:
+    return builtins_sum(id)
+
+
+builtins_sum = __builtins__["sum"] if isinstance(__builtins__, dict) else getattr(__builtins__, "sum")
+
+
+def avg(id: list[float]) -> float:
+    return sum(id) / len(id)
+
+
+def min(id: list[float]) -> float:
+    return builtins_min(id)
+
+
+builtins_min = __builtins__["min"] if isinstance(__builtins__, dict) else getattr(__builtins__, "min")
+
+
+def max(id: list[float]) -> float:
+    return builtins_max(id)
+
+
+builtins_max = __builtins__["max"] if isinstance(__builtins__, dict) else getattr(__builtins__, "max")
+
+
+def median(id: list[float]) -> float:
+    sorted_arr = sorted(id)
+    mid = len(sorted_arr) // 2
+    if len(sorted_arr) % 2 == 0:
+        return (sorted_arr[mid - 1] + sorted_arr[mid]) / 2
+    return sorted_arr[mid]
+
+
+def mode(id: list[float]) -> float:
+    frequency: dict[float, int] = {}
+    max_freq = 0
+    result = id[0]
+    for val in id:
+        freq = frequency.get(val, 0) + 1
+        frequency[val] = freq
+        if freq > max_freq:
+            max_freq = freq
+            result = val
+    return result
+
+
+def stdev(id: list[float]) -> float:
+    mean = avg(id)
+    square_diffs = [(v - mean) ** 2 for v in id]
+    return math.sqrt(builtins_sum(square_diffs) / len(id))
+
+
+def variance(id: list[float]) -> float:
+    mean = avg(id)
+    square_diffs = [(v - mean) ** 2 for v in id]
+    return builtins_sum(square_diffs) / len(id)
+
+
+def fill(id: list, value: Any, index_from: int = 0, index_to: int | None = None) -> None:
+    end = index_to if index_to is not None else len(id)
+    for i in range(index_from, end):
+        id[i] = value
+
+
+def from_array(id: list) -> list:
+    return copy(id)
+
+
+def first(id: list) -> Any:
+    return id[0]
+
+
+def last(id: list) -> Any:
+    return id[-1]
+
+
+def some(id: list, predicate: Callable) -> bool:
+    return any(predicate(x) for x in id)
+
+
+def every(id: list, predicate: Callable) -> bool:
+    return all(predicate(x) for x in id)
+
+
+def new_bool(size: int = 0, initial_value: bool = False) -> list[bool]:
+    return new_array(size, initial_value)
+
+
+def new_float(size: int = 0, initial_value: float = float("nan")) -> list[float]:
+    return new_array(size, initial_value)
+
+
+def new_int(size: int = 0, initial_value: int | float = float("nan")) -> list:
+    return new_array(size, initial_value)
+
+
+def new_string(size: int = 0, initial_value: str | None = None) -> list:
+    return new_array(size, initial_value)
+
+
+def new_color(size: int = 0, initial_value: Any = None) -> list:
+    return new_array(size, initial_value)
+
+
+def new_line(size: int = 0, initial_value: Any = None) -> list:
+    return new_array(size, initial_value)
+
+
+def new_box(size: int = 0, initial_value: Any = None) -> list:
+    return new_array(size, initial_value)
+
+
+def new_label(size: int = 0, initial_value: Any = None) -> list:
+    return new_array(size, initial_value)
+
+
+def new_linefill(size: int = 0, initial_value: Any = None) -> list:
+    return new_array(size, initial_value)
+
+
+def abs(id: list[float]) -> list[float]:
+    return [builtins_abs(x) for x in id]
+
+
+builtins_abs = __builtins__["abs"] if isinstance(__builtins__, dict) else getattr(__builtins__, "abs")
+
+
+def range(id: list[float]) -> float:
+    if len(id) == 0:
+        return float("nan")
+    return max(id) - min(id)
+
+
+def binary_search(id: list[float], val: float) -> int:
+    left, right = 0, len(id) - 1
+    while left <= right:
+        mid = (left + right) // 2
+        if id[mid] == val:
+            return mid
+        if id[mid] < val:
+            left = mid + 1
+        else:
+            right = mid - 1
+    return -1
+
+
+def binary_search_leftmost(id: list[float], val: float) -> int:
+    left, right = 0, len(id) - 1
+    result = -1
+    found = False
+    while left <= right:
+        mid = (left + right) // 2
+        if id[mid] < val:
+            if not found:
+                result = mid
+            left = mid + 1
+        elif id[mid] == val:
+            result = mid
+            found = True
+            right = mid - 1
+        else:
+            right = mid - 1
+    return result
+
+
+def binary_search_rightmost(id: list[float], val: float) -> int:
+    left, right = 0, len(id) - 1
+    result = -1
+    found = False
+    while left <= right:
+        mid = (left + right) // 2
+        if id[mid] <= val:
+            if id[mid] == val:
+                result = mid
+                found = True
+            left = mid + 1
+        else:
+            if not found:
+                result = mid
+            right = mid - 1
+    return result
+
+
+def covariance(id1: list[float], id2: list[float], biased: bool = True) -> float:
+    if not id1 or not id2 or len(id1) != len(id2):
+        return float("nan")
+    n = len(id1)
+    mean1 = avg(id1)
+    mean2 = avg(id2)
+    total = builtins_sum((id1[i] - mean1) * (id2[i] - mean2) for i in builtins_range(n))
+    divisor = n if biased else n - 1
+    return total / divisor
+
+
+builtins_range = __builtins__["range"] if isinstance(__builtins__, dict) else getattr(__builtins__, "range")
+
+
+def percentile_linear_interpolation(id: list[float], percentage: float) -> float:
+    if not id:
+        return float("nan")
+    sorted_arr = sorted(id)
+    n = len(sorted_arr)
+    rank = (percentage / 100) * (n - 1)
+    lower_idx = int(rank)
+    upper_idx = builtins_min(lower_idx + 1, n - 1)
+    frac = rank - lower_idx
+    return sorted_arr[lower_idx] + frac * (sorted_arr[upper_idx] - sorted_arr[lower_idx])
+
+
+def percentile_nearest_rank(id: list[float], percentage: float) -> float:
+    if not id:
+        return float("nan")
+    sorted_arr = sorted(id)
+    n = len(sorted_arr)
+    rank = int(math.ceil((percentage / 100) * n)) - 1
+    rank = builtins_max(0, builtins_min(rank, n - 1))
+    return sorted_arr[rank]
+
+
+builtins_max = __builtins__["max"] if isinstance(__builtins__, dict) else getattr(__builtins__, "max")
+
+
+def percentrank(id: list[float], index: int) -> float:
+    if not id or index < 0 or index >= len(id):
+        return float("nan")
+    value = id[index]
+    if math.isnan(value):
+        return float("nan")
+    count = builtins_sum(1 for v in id if not math.isnan(v) and v <= value)
+    return (count / len(id)) * 100
+
+
+def sort_indices(id: list[float], order: str = "asc") -> list[int]:
+    indices = list(builtins_range(len(id)))
+    indices.sort(key=lambda i: id[i], reverse=(order == "desc"))
+    return indices
+
+
+def standardize(id: list[float]) -> list[float]:
+    if not id:
+        return []
+    mean = avg(id)
+    std_dev = stdev(id)
+    if std_dev == 0:
+        return [float("nan")] * len(id)
+    return [(v - mean) / std_dev for v in id]

oakscriptpy/box.py

@@ -0,0 +1,151 @@
+"""Box namespace — mirrors PineScript box.* functions."""
+
+from __future__ import annotations
+
+import copy as _copy
+
+from ._types import Box
+
+
+def new(
+    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,
+) -> Box:
+    return Box(
+        left=left, top=top, right=right, bottom=bottom,
+        xloc=xloc, extend=extend,
+        border_color=border_color, border_width=border_width or 1,
+        border_style=border_style or "solid", bgcolor=bgcolor,
+        text=text, text_size=text_size, text_color=text_color,
+        text_halign=text_halign, text_valign=text_valign,
+        text_wrap=text_wrap, text_font_family=text_font_family,
+    )
+
+
+def get_left(id: Box) -> float:
+    return id.left
+
+
+def get_right(id: Box) -> float:
+    return id.right
+
+
+def get_top(id: Box) -> float:
+    return id.top
+
+
+def get_bottom(id: Box) -> float:
+    return id.bottom
+
+
+def copy(id: Box) -> Box:
+    return _copy.copy(id)
+
+
+def set_left(id: Box, left: float) -> Box:
+    id.left = left
+    return id
+
+
+def set_right(id: Box, right: float) -> Box:
+    id.right = right
+    return id
+
+
+def set_top(id: Box, top: float) -> Box:
+    id.top = top
+    return id
+
+
+def set_bottom(id: Box, bottom: float) -> Box:
+    id.bottom = bottom
+    return id
+
+
+def set_lefttop(id: Box, left: float, top: float) -> Box:
+    id.left = left
+    id.top = top
+    return id
+
+
+def set_rightbottom(id: Box, right: float, bottom: float) -> Box:
+    id.right = right
+    id.bottom = bottom
+    return id
+
+
+def set_xloc(id: Box, left: float, right: float, xloc: str) -> Box:
+    id.left = left
+    id.right = right
+    id.xloc = xloc
+    return id
+
+
+def set_extend(id: Box, extend: str) -> Box:
+    id.extend = extend
+    return id
+
+
+def set_border_color(id: Box, color: str | int) -> Box:
+    id.border_color = color
+    return id
+
+
+def set_border_width(id: Box, width: int) -> Box:
+    id.border_width = width
+    return id
+
+
+def set_border_style(id: Box, style: str) -> Box:
+    id.border_style = style
+    return id
+
+
+def set_bgcolor(id: Box, color: str | int) -> Box:
+    id.bgcolor = color
+    return id
+
+
+def set_text(id: Box, text: str) -> Box:
+    id.text = text
+    return id
+
+
+def set_text_color(id: Box, color: str | int) -> Box:
+    id.text_color = color
+    return id
+
+
+def set_text_size(id: Box, size: str | int) -> Box:
+    id.text_size = size
+    return id
+
+
+def set_text_halign(id: Box, align: str) -> Box:
+    id.text_halign = align
+    return id
+
+
+def set_text_valign(id: Box, align: str) -> Box:
+    id.text_valign = align
+    return id
+
+
+def set_text_wrap(id: Box, wrap: str) -> Box:
+    id.text_wrap = wrap
+    return id
+
+
+def set_text_font_family(id: Box, font: str) -> Box:
+    id.text_font_family = font
+    return id
+
+
+def delete(id: Box) -> None:
+    pass

oakscriptpy/chartpoint.py

@@ -0,0 +1,21 @@
+"""ChartPoint namespace — mirrors PineScript chart.point.* functions."""
+
+from __future__ import annotations
+
+from ._types import ChartPoint
+
+
+def new(time: float | None, index: int | None, price: float) -> ChartPoint:
+    return ChartPoint(time=time, index=index, price=price)
+
+
+def from_time(time: float, price: float) -> ChartPoint:
+    return ChartPoint(time=time, index=None, price=price)
+
+
+def from_index(index: int, price: float) -> ChartPoint:
+    return ChartPoint(time=None, index=index, price=price)
+
+
+def copy(point: ChartPoint) -> ChartPoint:
+    return ChartPoint(time=point.time, index=point.index, price=point.price)

oakscriptpy/color.py

@@ -0,0 +1,134 @@
+"""Color namespace — mirrors PineScript color.* functions."""
+
+from __future__ import annotations
+
+import re
+
+# Named color constants
+aqua = "#00FFFF"
+black = "#000000"
+blue = "#0000FF"
+fuchsia = "#FF00FF"
+gray = "#808080"
+green = "#00FF00"
+lime = "#00FF00"
+maroon = "#800000"
+navy = "#000080"
+olive = "#808000"
+orange = "#FFA500"
+purple = "#800080"
+red = "#FF0000"
+silver = "#C0C0C0"
+teal = "#008080"
+white = "#FFFFFF"
+yellow = "#FFFF00"
+
+
+def rgb(red: int, green: int, blue: int, transp: float | None = None) -> str:
+    r = max(0, min(255, red))
+    g = max(0, min(255, green))
+    b = max(0, min(255, blue))
+    a = 1 - (transp / 100) if transp is not None else 1.0
+    if a == 1:
+        return f"rgb({r}, {g}, {b})"
+    return f"rgba({r}, {g}, {b}, {a})"
+
+
+def from_hex(hex_str: str, transp: float | None = None) -> str:
+    hex_str = hex_str.lstrip("#")
+    r = int(hex_str[0:2], 16)
+    g = int(hex_str[2:4], 16)
+    b = int(hex_str[4:6], 16)
+    return rgb(r, g, b, transp)
+
+
+def new_color(base_color: str, transp: float) -> str:
+    rgba = _parse_color(base_color)
+    return rgb(rgba["r"], rgba["g"], rgba["b"], transp)
+
+
+# Alias for PineScript color.new()
+new = new_color
+
+
+def r(clr: str) -> int:
+    return _parse_color(clr)["r"]
+
+
+def g(clr: str) -> int:
+    return _parse_color(clr)["g"]
+
+
+def b(clr: str) -> int:
+    return _parse_color(clr)["b"]
+
+
+def t(clr: str) -> float:
+    return _parse_color(clr)["t"]
+
+
+def from_gradient(
+    value: float,
+    bottom_value: float,
+    top_value: float,
+    bottom_color: str,
+    top_color: str,
+) -> str:
+    c1 = _parse_color_rgba(bottom_color)
+    c2 = _parse_color_rgba(top_color)
+
+    if value <= bottom_value:
+        f = 0.0
+    elif value >= top_value:
+        f = 1.0
+    else:
+        f = (value - bottom_value) / (top_value - bottom_value)
+
+    r = builtins_round(c1[0] + (c2[0] - c1[0]) * f)
+    g = builtins_round(c1[1] + (c2[1] - c1[1]) * f)
+    b = builtins_round(c1[2] + (c2[2] - c1[2]) * f)
+    a = c1[3] + (c2[3] - c1[3]) * f
+
+    if a == 1:
+        return f"rgb({r}, {g}, {b})"
+    return f"rgba({r}, {g}, {b}, {a})"
+
+
+builtins_round = __builtins__["round"] if isinstance(__builtins__, dict) else getattr(__builtins__, "round")
+
+
+def _parse_color(clr: str) -> dict:
+    if isinstance(clr, str):
+        m = re.match(r"rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)", clr)
+        if m:
+            return {
+                "r": int(m.group(1)),
+                "g": int(m.group(2)),
+                "b": int(m.group(3)),
+                "t": (1 - float(m.group(4))) * 100 if m.group(4) else 0.0,
+            }
+        if clr.startswith("#"):
+            h = clr.lstrip("#")
+            return {
+                "r": int(h[0:2], 16),
+                "g": int(h[2:4], 16),
+                "b": int(h[4:6], 16),
+                "t": 0.0,
+            }
+    return {"r": 0, "g": 0, "b": 0, "t": 0.0}
+
+
+def _parse_color_rgba(clr: str) -> tuple[int, int, int, float]:
+    if isinstance(clr, str):
+        if clr.startswith("#"):
+            h = clr.lstrip("#")
+            return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16), 1.0)
+        m = re.match(r"rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)", clr)
+        if m:
+            return (
+                int(m.group(1)),
+                int(m.group(2)),
+                int(m.group(3)),
+                float(m.group(4)) if m.group(4) else 1.0,
+            )
+    return (0, 0, 0, 1.0)