py-alpha-lib 0.1.0__cp311-abi3-macosx_11_0_arm64.whl

alpha/__init__.py

@@ -0,0 +1,8 @@
+from .algo import *
+from .lang import *
+
+
+# skip nan values during computations
+FLAG_SKIP_NAN: int = 1
+# strictly cycle over the data
+FLAG_STRICTLY_CYCLE: int = 2

alpha/algo/__init__.py

@@ -0,0 +1,3 @@
+from .algo import EMA
+from .algo_gen import *
+from ._algo import set_ctx

alpha/algo/algo.md

@@ -0,0 +1,98 @@
+# Algo
+## barslast
+Bars since last condition true
+
+Ref: https://www.amibroker.com/guide/afl/barslast.html
+
+## barssince
+Bars since first condition true
+
+Ref: https://www.amibroker.com/guide/afl/barssince.html
+
+## count
+Count periods where condition is true
+
+Ref: https://www.amibroker.com/guide/afl/count.html
+
+## cross
+CROSS(A, B): Previous A < B, Current A >= B
+
+Ref: https://www.amibroker.com/guide/afl/cross.html
+
+## dma
+Exponential Moving Average
+
+https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+
+current = alpha * current + (1 - alpha) * previous
+
+
+## hhv
+Highest High Value
+
+Ref: https://www.amibroker.com/guide/afl/hhv.html
+
+## hhvbars
+Bars since Highest High Value
+
+Ref: https://www.amibroker.com/guide/afl/hhvbars.html
+
+## llv
+Lowest Low Value
+
+Ref: https://www.amibroker.com/guide/afl/llv.html
+
+## llvbars
+Bars since Lowest Low Value
+
+Ref: https://www.amibroker.com/guide/afl/llvbars.html
+
+## longcross
+LONGCROSS(A,B,N): Previous N A < B, Current A >= B
+
+## ma
+Moving Average
+
+https://en.wikipedia.org/wiki/Moving_average#Simple_moving_average
+
+
+
+## rank
+rank by group dim
+
+## rcross
+RCROSE(A, B): Previous A > B, Current A <= B
+
+## ref
+Reference to value N periods ago
+
+Ref: https://www.amibroker.com/guide/afl/ref.html
+
+## rlongcross
+RLONGCROSS(A,B,N): Previous N A > B, Current A <= B
+
+## sma
+Exponential Moving Average (variant of EMA)
+
+alpha = m / n
+
+https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+
+
+## sum
+Sum of value N periods ago
+
+If periods is 0, it calculates the cumulative sum from the first valid value.
+
+Ref: https://www.amibroker.com/guide/afl/sum.html
+
+## sumbars
+Sums X backwards until the sum is greater than or equal to A
+
+Returns the number of periods (bars) passed.
+
+Ref: https://www.amibroker.com/guide/afl/sumbars.html
+
+## ts_rank
+rank by ts dim
+

alpha/algo/algo.py

@@ -0,0 +1,29 @@
+import numpy as np
+from . import _algo
+
+
+def EMA(
+  input: np.ndarray | list[np.ndarray], period: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Exponential Moving Average (variant of EMA)
+
+  alpha = 2 / (n + 1)
+
+  https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+
+  Args:
+    input: input array
+    period: period
+
+  Returns:
+    output array
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.ema(r, input, period)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.ema(r, input, period)
+    return r

alpha/algo/algo_gen.py

@@ -0,0 +1,456 @@
+# THIS FILE IS AUTO-GENERATED, DO NOT EDIT
+
+import numpy as np
+from . import _algo
+
+def BARSLAST(
+  input: np.ndarray | list[np.ndarray]
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate number of bars since last condition true
+  
+  Ref: https://www.amibroker.com/guide/afl/barslast.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x, dtype=float) for x in input]
+    input = [x.astype(bool) for x in input]
+    _algo.barslast(r, input)
+    return r
+  else:
+    r = np.empty_like(input, dtype=float)
+    input = input.astype(bool)
+    _algo.barslast(r, input)
+    return r
+
+def BARSSINCE(
+  input: np.ndarray | list[np.ndarray]
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate number of bars since first condition true
+  
+  Ref: https://www.amibroker.com/guide/afl/barssince.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x, dtype=float) for x in input]
+    input = [x.astype(bool) for x in input]
+    _algo.barssince(r, input)
+    return r
+  else:
+    r = np.empty_like(input, dtype=float)
+    input = input.astype(bool)
+    _algo.barssince(r, input)
+    return r
+
+def CORR(
+  x: np.ndarray | list[np.ndarray], y: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate Correlation over a moving window
+  
+  Correlation = Cov(X, Y) / (StdDev(X) * StdDev(Y))
+  """
+  if isinstance(x, list) and isinstance(y, list):
+    r = [np.empty_like(x) for x in x]
+    x = [x.astype(float) for x in x]
+    y = [x.astype(float) for x in y]
+    _algo.corr(r, x, y, periods)
+    return r
+  else:
+    r = np.empty_like(x)
+    x = x.astype(float)
+    y = y.astype(float)
+    _algo.corr(r, x, y, periods)
+    return r
+
+def COUNT(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate number of periods where condition is true in passed `periods` window
+  
+  Ref: https://www.amibroker.com/guide/afl/count.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x, dtype=float) for x in input]
+    input = [x.astype(bool) for x in input]
+    _algo.count(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input, dtype=float)
+    input = input.astype(bool)
+    _algo.count(r, input, periods)
+    return r
+
+def COV(
+  x: np.ndarray | list[np.ndarray], y: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate Covariance over a moving window
+  
+  Covariance = (SumXY - (SumX * SumY) / N) / (N - 1)
+  """
+  if isinstance(x, list) and isinstance(y, list):
+    r = [np.empty_like(x) for x in x]
+    x = [x.astype(float) for x in x]
+    y = [x.astype(float) for x in y]
+    _algo.cov(r, x, y, periods)
+    return r
+  else:
+    r = np.empty_like(x)
+    x = x.astype(float)
+    y = y.astype(float)
+    _algo.cov(r, x, y, periods)
+    return r
+
+def CROSS(
+  a: np.ndarray | list[np.ndarray], b: np.ndarray | list[np.ndarray]
+) -> np.ndarray | list[np.ndarray]:
+  """
+  For 2 arrays A and B, return true if A[i-1] < B[i-1] and A[i] >= B[i]
+  alias: golden_cross, cross_ge
+  """
+  if isinstance(a, list) and isinstance(b, list):
+    r = [np.empty_like(x, dtype=bool) for x in a]
+    a = [x.astype(float) for x in a]
+    b = [x.astype(float) for x in b]
+    _algo.cross(r, a, b)
+    return r
+  else:
+    r = np.empty_like(a, dtype=bool)
+    a = a.astype(float)
+    b = b.astype(float)
+    _algo.cross(r, a, b)
+    return r
+
+def DMA(
+  input: np.ndarray | list[np.ndarray], weight: float
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Exponential Moving Average
+  current = weight * current + (1 - weight) * previous
+  
+  Ref: https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.dma(r, input, weight)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.dma(r, input, weight)
+    return r
+
+def HHV(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Find highest value in a preceding `periods` window
+  
+  Ref: https://www.amibroker.com/guide/afl/hhv.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.hhv(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.hhv(r, input, periods)
+    return r
+
+def HHVBARS(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  The number of periods that have passed since the array reached its `periods` period high
+  
+  Ref: https://www.amibroker.com/guide/afl/hhvbars.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.hhvbars(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.hhvbars(r, input, periods)
+    return r
+
+def LLV(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Find lowest value in a preceding `periods` window
+  
+  Ref: https://www.amibroker.com/guide/afl/llv.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.llv(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.llv(r, input, periods)
+    return r
+
+def LLVBARS(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  The number of periods that have passed since the array reached its periods period low
+  
+  Ref: https://www.amibroker.com/guide/afl/llvbars.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.llvbars(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.llvbars(r, input, periods)
+    return r
+
+def LONGCROSS(
+  a: np.ndarray | list[np.ndarray], b: np.ndarray | list[np.ndarray], n: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  For 2 arrays A and B, return true if previous N periods A < B, Current A >= B
+  """
+  if isinstance(a, list) and isinstance(b, list):
+    r = [np.empty_like(x, dtype=bool) for x in a]
+    a = [x.astype(float) for x in a]
+    b = [x.astype(float) for x in b]
+    _algo.longcross(r, a, b, n)
+    return r
+  else:
+    r = np.empty_like(a, dtype=bool)
+    a = a.astype(float)
+    b = b.astype(float)
+    _algo.longcross(r, a, b, n)
+    return r
+
+def LWMA(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Linear Weighted Moving Average
+  
+  LWMA = SUM(Price * Weight) / SUM(Weight)
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.lwma(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.lwma(r, input, periods)
+    return r
+
+def MA(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Simple Moving Average, also known as arithmetic moving average
+  
+  Ref: https://en.wikipedia.org/wiki/Moving_average#Simple_moving_average
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.ma(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.ma(r, input, periods)
+    return r
+
+def PRODUCT(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate product of values in preceding `periods` window
+  
+  If periods is 0, it calculates the cumulative product from the first valid value.
+  
+  Ref: https://www.amibroker.com/guide/afl/product.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.product(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.product(r, input, periods)
+    return r
+
+def RANK(
+  input: np.ndarray | list[np.ndarray]
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate rank percentage cross group dimension, the ctx.groups() is the number of groups
+  Same value are averaged
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.rank(r, input)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.rank(r, input)
+    return r
+
+def RCROSS(
+  a: np.ndarray | list[np.ndarray], b: np.ndarray | list[np.ndarray]
+) -> np.ndarray | list[np.ndarray]:
+  """
+  For 2 arrays A and B, return true if A[i-1] > B[i-1] and A[i] <= B[i]
+  alias: death_cross, cross_le
+  """
+  if isinstance(a, list) and isinstance(b, list):
+    r = [np.empty_like(x, dtype=bool) for x in a]
+    a = [x.astype(float) for x in a]
+    b = [x.astype(float) for x in b]
+    _algo.rcross(r, a, b)
+    return r
+  else:
+    r = np.empty_like(a, dtype=bool)
+    a = a.astype(float)
+    b = b.astype(float)
+    _algo.rcross(r, a, b)
+    return r
+
+def REF(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Right shift input array by `periods`, r[i] = input[i - periods]
+  
+  Ref: https://www.amibroker.com/guide/afl/ref.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.ref(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.ref(r, input, periods)
+    return r
+
+def RLONGCROSS(
+  a: np.ndarray | list[np.ndarray], b: np.ndarray | list[np.ndarray], n: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  For 2 arrays A and B, return true if previous N periods A > B, Current A <= B
+  """
+  if isinstance(a, list) and isinstance(b, list):
+    r = [np.empty_like(x, dtype=bool) for x in a]
+    a = [x.astype(float) for x in a]
+    b = [x.astype(float) for x in b]
+    _algo.rlongcross(r, a, b, n)
+    return r
+  else:
+    r = np.empty_like(a, dtype=bool)
+    a = a.astype(float)
+    b = b.astype(float)
+    _algo.rlongcross(r, a, b, n)
+    return r
+
+def SMA(
+  input: np.ndarray | list[np.ndarray], n: int, m: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Exponential Moving Average (variant of well-known EMA) weight = m / n
+  
+  Ref: https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.sma(r, input, n, m)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.sma(r, input, n, m)
+    return r
+
+def STDDEV(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate Standard Deviation over a moving window
+  
+  Ref: https://en.wikipedia.org/wiki/Standard_deviation
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.stddev(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.stddev(r, input, periods)
+    return r
+
+def SUM(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate sum of values in preceding `periods` window
+  
+  If periods is 0, it calculates the cumulative sum from the first valid value.
+  
+  Ref: https://www.amibroker.com/guide/afl/sum.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.sum(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.sum(r, input, periods)
+    return r
+
+def SUMBARS(
+  input: np.ndarray | list[np.ndarray], amount: float
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate number of periods (bars) backwards until the sum of values is greater than or equal to `amount`
+  
+  Ref: https://www.amibroker.com/guide/afl/sumbars.html
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.sumbars(r, input, amount)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.sumbars(r, input, amount)
+    return r
+
+def TS_RANK(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate rank in a sliding window with size `periods`
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.ts_rank(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.ts_rank(r, input, periods)
+    return r
+
+def VAR(
+  input: np.ndarray | list[np.ndarray], periods: int
+) -> np.ndarray | list[np.ndarray]:
+  """
+  Calculate Variance over a moving window
+  
+  Variance = (SumSq - (Sum^2)/N) / (N - 1)
+  """
+  if isinstance(input, list):
+    r = [np.empty_like(x) for x in input]
+    _algo.var(r, input, periods)
+    return r
+  else:
+    r = np.empty_like(input)
+    _algo.var(r, input, periods)
+    return r
+

alpha/algo.md

@@ -0,0 +1,30 @@
+List of available functions with python type hints:
+
+the `np.ndarray` is `ndarray` type in `numpy` package
+
+- BARSLAST(input: np.ndarray[bool]): Calculate number of bars since last condition true
+- BARSSINCE(input: np.ndarray[bool]): Calculate number of bars since first condition true
+- CORR(x: np.ndarray[float], y: np.ndarray[float], periods: int): Calculate Correlation over a moving window  Correlation = Cov(X, Y) / (StdDev(X) * StdDev(Y))
+- COUNT(input: np.ndarray[bool], periods: int): Calculate number of periods where condition is true in passed `periods` window
+- COV(x: np.ndarray[float], y: np.ndarray[float], periods: int): Calculate Covariance over a moving window  Covariance = (SumXY - (SumX * SumY) / N) / (N - 1)
+- CROSS(a: np.ndarray[float], b: np.ndarray[float]): For 2 arrays A and B, return true if A[i-1] < B[i-1] and A[i] >= B[i] alias: golden_cross, cross_ge
+- DMA(input: np.ndarray[float], weight: float): Exponential Moving Average current = weight * current + (1 - weight) * previous
+- EMA(input: np.ndarray[float], periods: int): Exponential Moving Average (variant of well-known EMA) weight = 2 / (n + 1)
+- HHV(input: np.ndarray[float], periods: int): Find highest value in a preceding `periods` window
+- HHVBARS(input: np.ndarray[float], periods: int): The number of periods that have passed since the array reached its `periods` period high
+- LLV(input: np.ndarray[float], periods: int): Find lowest value in a preceding `periods` window
+- LLVBARS(input: np.ndarray[float], periods: int): The number of periods that have passed since the array reached its periods period low
+- LONGCROSS(a: np.ndarray[float], b: np.ndarray[float], n: int): For 2 arrays A and B, return true if previous N periods A < B, Current A >= B
+- LWMA(input: np.ndarray[float], periods: int): Linear Weighted Moving Average  LWMA = SUM(Price * Weight) / SUM(Weight)
+- MA(input: np.ndarray[float], periods: int): Simple Moving Average, also known as arithmetic moving average
+- PRODUCT(input: np.ndarray[float], periods: int): Calculate product of values in preceding `periods` window  If periods is 0, it calculates the cumulative product from the first valid value.
+- RANK(input: np.ndarray[float]): Calculate rank percentage cross group dimension, the ctx.groups() is the number of groups Same value are averaged
+- RCROSS(a: np.ndarray[float], b: np.ndarray[float]): For 2 arrays A and B, return true if A[i-1] > B[i-1] and A[i] <= B[i] alias: death_cross, cross_le
+- REF(input: np.ndarray[float], periods: int): Right shift input array by `periods`, r[i] = input[i - periods]
+- RLONGCROSS(a: np.ndarray[float], b: np.ndarray[float], n: int): For 2 arrays A and B, return true if previous N periods A > B, Current A <= B
+- SMA(input: np.ndarray[float], n: int, m: int): Exponential Moving Average (variant of well-known EMA) weight = m / n
+- STDDEV(input: np.ndarray[float], periods: int): Calculate Standard Deviation over a moving window
+- SUM(input: np.ndarray[float], periods: int): Calculate sum of values in preceding `periods` window  If periods is 0, it calculates the cumulative sum from the first valid value.
+- SUMBARS(input: np.ndarray[float], amount: float): Calculate number of periods (bars) backwards until the sum of values is greater than or equal to `amount`
+- TS_RANK(input: np.ndarray[float], periods: int): Calculate rank in a sliding window with size `periods`
+- VAR(input: np.ndarray[float], periods: int): Calculate Variance over a moving window  Variance = (SumSq - (Sum^2)/N) / (N - 1)

alpha/lang/__init__.py

@@ -0,0 +1 @@
+from .to_python import to_python, to_python_file

alpha/lang/__main__.py

@@ -0,0 +1,17 @@
+from .to_python import to_python_file
+
+if __name__ == "__main__":
+  import sys
+  import pathlib
+
+  if len(sys.argv) < 2:
+    print("Usage: python -m alpha.lang <file | code>")
+    sys.exit(1)
+
+  file_path = pathlib.Path(sys.argv[1])
+  if file_path.exists():
+    codes = file_path.read_text().splitlines()
+    to_python_file(codes, name_convertor=lambda x: x.upper())
+  else:
+    code = "\n".join(sys.argv[1:])
+    to_python_file([code], name_convertor=lambda x: x.upper())

alpha/lang/alpha.lark

@@ -0,0 +1,49 @@
+start: expression
+
+?expression: ternary_expr
+
+?ternary_expr: logical_or_expr "?" ternary_expr ":" ternary_expr
+             | logical_or_expr
+
+?logical_or_expr: logical_and_expr ("||" logical_and_expr)*
+
+?logical_and_expr: comparison_expr ("&&" comparison_expr)*
+
+?comparison_expr: sum "==" sum -> eq
+                | sum "!=" sum -> ne
+                | sum "<" sum  -> lt
+                | sum ">" sum  -> gt
+                | sum "<=" sum -> le
+                | sum ">=" sum -> ge
+                | sum
+
+?sum: product (add_op product)*
+
+?product: power (mul_op power)*
+
+?power: atom (POWER atom)*
+
+?atom: MINUS atom -> neg
+     | func_call
+     | NUMBER
+     | NAME
+     | NAME "." NAME -> dotted_name
+     | "(" expression ")"
+
+!add_op: PLUS | MINUS
+!mul_op: STAR | DIV
+
+func_call: NAME "(" [arguments] ")"
+arguments: expression ("," expression)*
+
+// Terminals
+PLUS: "+"
+MINUS: "-"
+STAR: "*"
+DIV: "/"
+POWER: "^"
+NUMBER: /\d+(\.\d*)?|\.\d+/
+NAME: /[a-zA-Z_]\w*/
+
+%import common.WS
+%ignore WS