oakscriptpy 0.1.0__py3-none-any.whl

oakscriptpy/ta_series.py

@@ -0,0 +1,353 @@
+"""Series-based TA wrappers — accepts/returns Series objects."""
+
+from __future__ import annotations
+
+from . import ta as ta_core
+from ._types import Bar
+from .series import Series
+
+
+def _bars_from(s: Series) -> list[Bar]:
+    return s.bars
+
+
+def _wrap(bars: list[Bar] | Series, values: list[float]) -> Series:
+    return Series.from_array(bars if isinstance(bars, list) else bars.bar_data, values)
+
+
+# --- Moving Averages ---
+
+def sma(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.sma(source.to_array(), length))
+
+
+def ema(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.ema(source.to_array(), length))
+
+
+def wma(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.wma(source.to_array(), length))
+
+
+def rma(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.rma(source.to_array(), length))
+
+
+def vwma(source: Series, length: int, volume: Series) -> Series:
+    return _wrap(source, ta_core.vwma(source.to_array(), length, volume.to_array()))
+
+
+def hma(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.hma(source.to_array(), length))
+
+
+def alma(source: Series, length: int = 9, offset: float = 0.85, sigma: float = 6, floor: bool = False) -> Series:
+    return _wrap(source, ta_core.alma(source.to_array(), length, offset, sigma, floor))
+
+
+def swma(source: Series) -> Series:
+    return _wrap(source, ta_core.swma(source.to_array()))
+
+
+def linreg(source: Series, length: int, offset: int = 0) -> Series:
+    return _wrap(source, ta_core.linreg(source.to_array(), length, offset))
+
+
+# --- Oscillators ---
+
+def rsi(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.rsi(source.to_array(), length))
+
+
+def stoch(source: Series, high: Series, low: Series, length: int) -> Series:
+    return _wrap(source, ta_core.stoch(source.to_array(), high.to_array(), low.to_array(), length))
+
+
+def cci(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.cci(source.to_array(), length))
+
+
+def cmo(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.cmo(source.to_array(), length))
+
+
+def tsi(source: Series, short_length: int, long_length: int) -> Series:
+    return _wrap(source, ta_core.tsi(source.to_array(), short_length, long_length))
+
+
+def mfi(source: Series, length: int, volume: Series) -> Series:
+    return _wrap(source, ta_core.mfi(source.to_array(), length, volume.to_array()))
+
+
+def cog(source: Series, length: int = 10) -> Series:
+    return _wrap(source, ta_core.cog(source.to_array(), length))
+
+
+def rci(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.rci(source.to_array(), length))
+
+
+def percentrank(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.percentrank(source.to_array(), length))
+
+
+# --- Bands & Channels ---
+
+def macd(source: Series, fast_length: int, slow_length: int, signal_length: int) -> tuple[Series, Series, Series]:
+    vals = ta_core.macd(source.to_array(), fast_length, slow_length, signal_length)
+    return _wrap(source, vals[0]), _wrap(source, vals[1]), _wrap(source, vals[2])
+
+
+def bb(source: Series, length: int, mult: float) -> tuple[Series, Series, Series]:
+    upper, basis, lower = ta_core.bb(source.to_array(), length, mult)
+    return _wrap(source, upper), _wrap(source, basis), _wrap(source, lower)
+
+
+def bbw(source: Series, length: int, mult: float) -> Series:
+    return _wrap(source, ta_core.bbw(source.to_array(), length, mult))
+
+
+def kc(bars: list[Bar], source: Series, length: int, mult: float, use_true_range: bool = True) -> tuple[Series, Series, Series]:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    middle, upper, lower = ta_core.kc(source.to_array(), length, mult, use_true_range, high, low, close)
+    return _wrap(bars, middle), _wrap(bars, upper), _wrap(bars, lower)
+
+
+def kcw(bars: list[Bar], source: Series, length: int = 20, mult: float = 2, use_true_range: bool = True) -> Series:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    return _wrap(bars, ta_core.kcw(source.to_array(), length, mult, use_true_range, high, low, close))
+
+
+# --- Volatility ---
+
+def stdev(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.stdev(source.to_array(), length))
+
+
+def variance(source: Series, length: int, biased: bool = True) -> Series:
+    return _wrap(source, ta_core.variance(source.to_array(), length, biased))
+
+
+def dev(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.dev(source.to_array(), length))
+
+
+def atr(bars: list[Bar], length: int) -> Series:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    return _wrap(bars, ta_core.atr(length, high, low, close))
+
+
+def tr(bars: list[Bar], handle_na: bool = False) -> Series:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    return _wrap(bars, ta_core.tr(handle_na, high, low, close))
+
+
+# --- Trend ---
+
+def supertrend(bars: list[Bar], factor: float, atr_length: int) -> tuple[Series, Series]:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    trend_vals, dir_vals = ta_core.supertrend(factor, atr_length, high, low, close)
+    return _wrap(bars, trend_vals), _wrap(bars, dir_vals)
+
+
+def vwap(source: Series, volume: Series) -> Series:
+    return _wrap(source, ta_core.vwap(source.to_array(), volume.to_array()))
+
+
+def sar(bars: list[Bar], start: float = 0.02, inc: float = 0.02, max_val: float = 0.2) -> Series:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    return _wrap(bars, ta_core.sar(start, inc, max_val, high, low, close))
+
+
+def ichimoku(
+    bars: list[Bar], conversion_periods: int, base_periods: int,
+    lagging_span2_periods: int, displacement: int,
+) -> tuple[Series, Series, Series, Series, Series]:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    tenkan, kijun, senkou_a, senkou_b, chikou = ta_core.ichimoku(
+        conversion_periods, base_periods, lagging_span2_periods, displacement, high, low, close,
+    )
+    return (
+        _wrap(bars, tenkan), _wrap(bars, kijun),
+        _wrap(bars, senkou_a), _wrap(bars, senkou_b), _wrap(bars, chikou),
+    )
+
+
+def dmi(bars: list[Bar], di_length: int, adx_smoothing: int) -> tuple[Series, Series, Series]:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    plus_di, minus_di, adx = ta_core.dmi(di_length, adx_smoothing, high, low, close)
+    return _wrap(bars, plus_di), _wrap(bars, minus_di), _wrap(bars, adx)
+
+
+# --- Cross Detection ---
+
+def crossover(source1: Series, source2: Series | float | int) -> Series:
+    vals1 = source1.to_array()
+    if isinstance(source2, Series):
+        vals2 = source2.to_array()
+    else:
+        vals2 = [float(source2)] * len(vals1)
+    result = ta_core.crossover(vals1, vals2)
+    return _wrap(source1, [1.0 if b else 0.0 for b in result])
+
+
+def crossunder(source1: Series, source2: Series | float | int) -> Series:
+    vals1 = source1.to_array()
+    if isinstance(source2, Series):
+        vals2 = source2.to_array()
+    else:
+        vals2 = [float(source2)] * len(vals1)
+    result = ta_core.crossunder(vals1, vals2)
+    return _wrap(source1, [1.0 if b else 0.0 for b in result])
+
+
+def cross(source1: Series, source2: Series | float | int) -> Series:
+    vals1 = source1.to_array()
+    if isinstance(source2, Series):
+        vals2 = source2.to_array()
+    else:
+        vals2 = [float(source2)] * len(vals1)
+    result = ta_core.cross(vals1, vals2)
+    return _wrap(source1, [1.0 if b else 0.0 for b in result])
+
+
+# --- Momentum ---
+
+def change(source: Series, length: int = 1) -> Series:
+    return _wrap(source, ta_core.change(source.to_array(), length))
+
+
+def mom(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.mom(source.to_array(), length))
+
+
+def roc(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.roc(source.to_array(), length))
+
+
+# --- Extremes ---
+
+def highest(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.highest(source.to_array(), length))
+
+
+def lowest(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.lowest(source.to_array(), length))
+
+
+def highestbars(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.highestbars(source.to_array(), length))
+
+
+def lowestbars(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.lowestbars(source.to_array(), length))
+
+
+# --- Detection ---
+
+def rising(source: Series, length: int) -> Series:
+    result = ta_core.rising(source.to_array(), length)
+    return _wrap(source, [1.0 if b else 0.0 for b in result])
+
+
+def falling(source: Series, length: int) -> Series:
+    result = ta_core.falling(source.to_array(), length)
+    return _wrap(source, [1.0 if b else 0.0 for b in result])
+
+
+def pivothigh(source: Series, leftbars: int, rightbars: int) -> Series:
+    return _wrap(source, ta_core.pivothigh(source.to_array(), leftbars, rightbars))
+
+
+def pivotlow(source: Series, leftbars: int, rightbars: int) -> Series:
+    return _wrap(source, ta_core.pivotlow(source.to_array(), leftbars, rightbars))
+
+
+# --- Cumulative & Stats ---
+
+def cum(source: Series) -> Series:
+    return _wrap(source, ta_core.cum(source.to_array()))
+
+
+def correlation(source1: Series, source2: Series, length: int) -> Series:
+    return _wrap(source1, ta_core.correlation(source1.to_array(), source2.to_array(), length))
+
+
+def median(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.median(source.to_array(), length))
+
+
+def mode(source: Series, length: int) -> Series:
+    return _wrap(source, ta_core.mode(source.to_array(), length))
+
+
+def percentile_linear_interpolation(source: Series, length: int, percentage: float) -> Series:
+    return _wrap(source, ta_core.percentile_linear_interpolation(source.to_array(), length, percentage))
+
+
+def percentile_nearest_rank(source: Series, length: int, percentage: float) -> Series:
+    return _wrap(source, ta_core.percentile_nearest_rank(source.to_array(), length, percentage))
+
+
+# --- Bar-based ---
+
+def barssince(condition: Series) -> Series:
+    bool_values = [v == 1 for v in condition.to_array()]
+    return _wrap(condition, ta_core.barssince(bool_values))
+
+
+def valuewhen(condition: Series, source: Series, occurrence: int) -> Series:
+    bool_values = [v == 1 for v in condition.to_array()]
+    return _wrap(condition, ta_core.valuewhen(bool_values, source.to_array(), occurrence))
+
+
+# --- Element-wise ---
+
+def max(source1: Series, source2: Series) -> Series:
+    return _wrap(source1, ta_core.max_(source1.to_array(), source2.to_array()))
+
+
+def min(source1: Series, source2: Series) -> Series:
+    return _wrap(source1, ta_core.min_(source1.to_array(), source2.to_array()))
+
+
+def range(high: Series, low: Series) -> Series:
+    return _wrap(high, ta_core.range_(high.to_array(), low.to_array()))
+
+
+# --- Complex indicators ---
+
+def zigzag(
+    bars: list[Bar], deviation: float = 5, depth: int = 10, backstep: int = 3,
+) -> tuple[Series, Series, Series]:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    zigzag_vals, dir_vals, pivot_vals = ta_core.zigzag(deviation, depth, backstep, None, high, low)
+    return (
+        _wrap(bars, zigzag_vals),
+        _wrap(bars, dir_vals),
+        _wrap(bars, [1.0 if b else 0.0 for b in pivot_vals]),
+    )
+
+
+def wpr(bars: list[Bar], length: int = 14) -> Series:
+    high = [b.high for b in bars]
+    low = [b.low for b in bars]
+    close = [b.close for b in bars]
+    return _wrap(bars, ta_core.wpr(high, low, close, length))

oakscriptpy/time_.py

@@ -0,0 +1,22 @@
+"""Time namespace — mirrors PineScript time functions."""
+
+from __future__ import annotations
+
+import time as _time
+from datetime import datetime
+
+
+def now() -> int:
+    return int(_time.time() * 1000)
+
+
+def timestamp(
+    year: int,
+    month: int,
+    day: int,
+    hour: int = 0,
+    minute: int = 0,
+    second: int = 0,
+) -> int:
+    dt = datetime(year, month, day, hour, minute, second)
+    return int(dt.timestamp() * 1000)

oakscriptpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: oakscriptpy
+Version: 0.1.0
+Summary: PineScript-like API for technical analysis in Python
+Project-URL: Homepage, https://github.com/deepentropy/oakscriptPy
+Project-URL: Repository, https://github.com/deepentropy/oakscriptPy
+Project-URL: Issues, https://github.com/deepentropy/oakscriptPy/issues
+Author: deepentropy
+License-Expression: MIT
+Keywords: finance,pinescript,ta,technical-analysis,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="./logo.png" width="150" />
+</p>
+
+<h1 align="center">OakScriptPy</h1>
+
+<p align="center">
+  PineScript-like API for technical analysis in Python. Pure Python, zero dependencies.
+</p>
+
+---
+
+## Install
+
+```bash
+pip install oakscriptpy
+```
+
+## Quick Start
+
+```python
+from oakscriptpy import ta, math, color, Series
+from oakscriptpy._types import Bar
+
+# Create bars
+bars = [
+    Bar(time=1, open=10.0, high=12.0, low=9.0, close=11.0, volume=100.0),
+    Bar(time=2, open=11.0, high=13.0, low=10.0, close=12.0, volume=110.0),
+    Bar(time=3, open=12.0, high=14.0, low=11.0, close=13.0, volume=120.0),
+    # ...
+]
+
+# Array-based TA
+closes = [b.close for b in bars]
+sma_values = ta.sma(closes, 3)
+ema_values = ta.ema(closes, 3)
+rsi_values = ta.rsi(closes, 14)
+
+# Series-based TA (with operator overloading)
+from oakscriptpy import ta as ta_series
+close_series = Series.from_bars(bars, lambda b: b.close)
+sma_series = ta_series.sma(close_series, 3)
+ema_series = ta_series.ema(close_series, 3)
+
+# Series arithmetic
+spread = close_series - sma_series
+doubled = close_series * 2
+above_sma = close_series > sma_series
+```
+
+## Namespaces
+
+| Namespace | Functions | Description |
+|-----------|-----------|-------------|
+| `ta` | 64 | Technical analysis (SMA, EMA, RSI, MACD, Bollinger Bands, Ichimoku, SuperTrend, ZigZag, etc.) |
+| `math` | 26 | Mathematical functions (abs, ceil, floor, sqrt, pow, trig, etc.) |
+| `array` | 42+ | Array manipulation (push, pop, sort, slice, binary_search, percentile, etc.) |
+| `color` | 14 + 17 constants | Color creation and manipulation (rgb, from_hex, new_color, named constants) |
+| `str` | 20+ | String functions (split, replace, substring, contains, match, etc.) |
+| `time` | 2 | Time utilities (format_time) |
+| `matrix` | 43 | Matrix operations (add, mult, det, inv, eigenvalues, eigenvectors, etc.) |
+| `line` | 10 | Line drawing objects |
+| `box` | 12 | Box drawing objects |
+| `label` | 10 | Label drawing objects |
+| `linefill` | 4 | Linefill functions |
+| `chart_point` | 3 | Chart point functions |
+| `polyline` | 5 | Polyline functions |
+
+## Series
+
+The `Series` class provides lazy evaluation with Python operator overloading:
+
+```python
+a = Series.from_bars(bars, lambda b: b.close)
+b = Series.from_bars(bars, lambda b: b.open)
+
+# Arithmetic: +, -, *, /, %
+spread = a - b
+
+# Comparison: >, >=, <, <=, eq(), neq()
+bullish = a > b
+
+# Logical: and_(), or_(), not_()
+signal = bullish.and_(a > sma_series)
+
+# History access
+prev_close = a.offset(1)
+```
+
+## Tests
+
+```bash
+uv run pytest
+# 1,224 passed, 56 skipped
+```
+
+## License
+
+MIT

oakscriptpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+oakscriptpy/__init__.py,sha256=i3T6t_SlkPpMLoIQlVsZi-bXWQdT9m8ivXNlLTWbVXo,2737
+oakscriptpy/_metadata.py,sha256=wwVjzgCoQ5usGjuMscaw8FoamHAm4yPnreuocum3GYE,2666
+oakscriptpy/_types.py,sha256=5xaSbo8OP639DLLDVOLyZY5o2fzFl5GtXV3lN8mjJu8,3763
+oakscriptpy/_utils.py,sha256=U_9d9etcUsW-cB9rLErrnuikY4XI0Rnh4Xazd6ThuAs,4001
+oakscriptpy/array.py,sha256=bgLCgGOs2-EQJ1ujhdEFoejS0PjCFiNGBS8XInAP9n8,8275
+oakscriptpy/box.py,sha256=fRGw_IkV1pqQsPPQBeK0yyWN3XArUbfR-yfRmKiSUpE,3197
+oakscriptpy/chartpoint.py,sha256=PM370m4NlKAC6VnEy5aQ06DJww_icGYg8a8GGGavHlk,635
+oakscriptpy/color.py,sha256=DUsDlJVrKYlNhN3Bs-RLkGwWWwEWmpWgtoXt-IdzMDQ,3425
+oakscriptpy/indicator.py,sha256=flmj9Ps3ruM0cAf_wFECyKbgHfewPafhnt5us3gKKLo,2209
+oakscriptpy/input_.py,sha256=B0Ou9-2Jae7N6Wd-p5oI-lKN0yE8RDFJ-YMgvQN1oFk,1672
+oakscriptpy/inputs.py,sha256=O_Tr08-PMEaGwVAA28boqlswA8DSzpmww9B9KdjDFC8,5347
+oakscriptpy/label.py,sha256=pzQcK9EyZrtkIXYC0gEAtjsT9sU8KMSi1azWZT7j9nk,2153
+oakscriptpy/line.py,sha256=DLIbqr5WjLL-W-48cHZQOA5teO76K1M3eb8m0RwkxGg,2349
+oakscriptpy/linefill.py,sha256=IQ-P5bPOnR1Sm325t4KaIE9oQIuZjM8TUE5B0MrzpiA,541
+oakscriptpy/math_.py,sha256=bS2223jYIrbuHtI_VRf38BCf_hAJ_NB73S2AujLS36U,3878
+oakscriptpy/matrix.py,sha256=yUifrNj-6t7Or4m1weJB7FXUVgxs8TGjFTUwH3eIboU,32448
+oakscriptpy/plot_.py,sha256=JlYcFNFfeDfepWqVaZfSy8KdOnXUl09alENz4oMovHY,1151
+oakscriptpy/polyline.py,sha256=luIc0D9puQECA49pd1MZP4N32D5in-2We1vK5LmgXso,1499
+oakscriptpy/runtime.py,sha256=nSiBwwNbuH7mE3YWiCf7TN2Z78cquFIPDQuHWZlJJUw,3924
+oakscriptpy/runtime_types.py,sha256=hhaZFrm5Z0z2fy1aNfe6Qx2svnW-Ur7lIISfbwbfrWQ,1346
+oakscriptpy/series.py,sha256=x7E2LMOT9XMIkkhtJRNtdOzQD6D5oGzirDdOHgBy3Z8,10563
+oakscriptpy/str_.py,sha256=v343ieUv9FE6FIHMA2VKHCB-BxSl-duVzlif0S6SZgU,3920
+oakscriptpy/ta.py,sha256=Voh1wADo4eqWiukNv8eMV9nASYRCb9NrEg_9phBKqtY,55351
+oakscriptpy/ta_series.py,sha256=26nkB-J4y3hIkLI8eH65UlgUtKoisChHPW0y6y9aCMw,11858
+oakscriptpy/time_.py,sha256=OKONmAOZ_ciH_gcdJMAnsRuy5ww4N0ttmyWaVNDH7T8,433
+oakscriptpy/adapters/__init__.py,sha256=dTCswDoAPkYrBxg8EpehPkq3LxgojjMcEfcY-pPVPnY,111
+oakscriptpy/adapters/simple_input.py,sha256=Y4EU39Qn198nHyfuv90FViGMvVLKx6ASy2rdrvH-8aI,2096
+oakscriptpy/lib/__init__.py,sha256=tMl14ueGpVPkMchWhLfN68QmZ4CNwjaP5K-C-MNh3nE,105
+oakscriptpy/lib/zigzag.py,sha256=pBcQRJGYhqBnop67BPSsFyhMd_F4rSiNXW_B-MgFqSw,5298
+oakscriptpy-0.1.0.dist-info/METADATA,sha256=Ec88p-eOKDvutQIP8mtii8XVopUnD1gB2U8PZ_ui75k,3508
+oakscriptpy-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+oakscriptpy-0.1.0.dist-info/RECORD,,

oakscriptpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any