def test_rsi(self):
df = pd.DataFrame(pd.util.testing.getTimeSeriesData(20))
adjust = False
period = 14
delta = df["A"].diff().shift(-1)
up, down = delta.copy(), delta.copy()
up[up < 0] = 0
down[down > 0] = 0
_gain = up.ewm(alpha=1.0 / period, adjust=adjust).mean()
_loss = down.abs().ewm(alpha=1.0 / period, adjust=adjust).mean()
RS = _gain / _loss
rsi = pd.Series(100 - (100 / (1 + RS)))
val = [df["A"].iloc[0]]
n = tl.Node(value=val)
n_rsi = n.rsi(period=period)
for i, x in enumerate(df["A"][1:]):
val.append(x)
n._dirty = True
print("data\t", i, x, n_rsi(), rsi[i])
assert abs(n_rsi() - rsi[i]) < 0.003
n = tl.Node(value=val)
n_rsi = n.rsi(period=period, basket=True)
assert n_rsi().tolist() == rsi.tolist()
def test_if(self):
import tributary.lazy as tl
x = tl.Node(value=func)
y = tl.Node(1)
z = tl.Node(-1)
out = tl.If(x, y, z)
print(out.graph())
assert out() == 1
assert out() == -1
assert out() == 1
assert out() == 1
assert out() == 1
def test_macd(self):
df = pd.DataFrame(pd.util.testing.getTimeSeriesData(20))
period_fast = 12
period_slow = 26
signal = 9
adjust = False
EMA_fast = pd.Series(
df["A"].ewm(ignore_na=False, span=period_fast,
adjust=adjust).mean(),
name="EMA_fast",
)
EMA_slow = pd.Series(
df["A"].ewm(ignore_na=False, span=period_slow,
adjust=adjust).mean(),
name="EMA_slow",
)
MACD = pd.Series(EMA_fast - EMA_slow, name="MACD")
MACD_signal = pd.Series(MACD.ewm(ignore_na=False,
span=signal,
adjust=adjust).mean(),
name="SIGNAL")
expected = pd.concat([MACD, MACD_signal], axis=1)
val = []
n = tl.Node(value=val)
n_macd = n.macd(period_fast=period_fast,
period_slow=period_slow,
signal=signal)
for i, x in enumerate(df["A"]):
val.append(x)
n_macd.setDirty(True)
ret = n_macd()
assert expected.values[i][0] - ret[0] < 0.001
assert expected.values[i][1] - ret[1] < 0.001
n = tl.Node(value=val)
n_macd = n.macd(period_fast=period_fast,
period_slow=period_slow,
signal=signal,
basket=True)
assert n_macd().tolist() == expected.values.tolist()
def test_callable_lock(self):
n = t.Node(value=random.random, dynamic=True)
x = n()
assert n() != x
n.setValue(5)
assert n() == 5
n.unlock()
assert n() != 5
def test_tolerance(self):
n = t.Node(value=1.0)
n2 = n + 1
assert n() == 1.0
assert n2() == 2.0
n.setValue(1.0000000000000001)
assert n2.isDirty() is False
n.setValue(1.0001)
assert n2.isDirty() is True
def test_lazy_default_func_arg(self):
def func(val, prev_val=0):
print("val:\t{}".format(val))
print("prev_val:\t{}".format(prev_val))
return val + prev_val
n = t.Node(value=func)
n.kwargs["val"].setValue(5)
assert n() == 5
n.set(prev_val=100)
assert n() == 105
def test_interval(self):
n = tl.Node(value=5)
out = tl.Interval(n, seconds=2)
# assert initial value
assert out() == 5
# set new value
n.setValue(6)
# continue to use old value until 2+ seconds elapsed
assert out() == 5
sleep(3)
assert out() == 6
def test_expire(self):
n = tl.Node(value=5)
sec = datetime.now().second
out = tl.Expire(n, second=(sec + 2) % 60)
# assert initial value
assert out() == 5
# set new value
n.setValue(6)
# continue to use old value until 2+ seconds elapsed
assert out() == 5
sleep(3)
assert out() == 6
def test_function(self):
def foo(*args):
for _ in range(5):
yield _
lazy_node = tl.Node(callable=foo) + 5
# 5 6 7 8 9
streaming_node = ts.Print(ts.Foo(foo) - 5, 'streaming:')
# -5 -4 -3 -2 -1
out = ts.Print(t.LazyToStreaming(lazy_node), 'lazy:') + streaming_node
x = ts.run(out)
# 0 2 4 6 8
print(x)
assert x == [0, 2, 4, 6, 8]
def test_function_order(self):
def foo(*args):
for _ in range(5):
yield _
lazy_node = tl.Node(callable=foo) + 5
# 5 6 7 8 9
streaming_node = ts.Print(ts.Foo(foo) - 5, "streaming:")
# -5 -4 -3 -2 -1
out = streaming_node + ts.Print(lazy_node, "lazy:")
x = ts.run(out)
# 0 2 4 6 8
print(x)
assert x == [0, 2, 4, 6, 8]
def test_function(self):
def func(*args):
for _ in range(5):
yield _
lazy_node = tl.Node(value=func) + 5
# 5 6 7 8 9
streaming_node = ts.Print(ts.Func(func) - 5, "streaming:")
# -5 -4 -3 -2 -1
out = ts.Print(t.LazyToStreaming(lazy_node), "lazy:") + streaming_node
x = ts.run(out)
# 0 2 4 6 8
print(x)
assert x == [0, 2, 4, 6, 8]
def test_tweaks(self):
n = tl.Node(name="Test", value=5)
n2 = n + 1
# base operation
print(n2())
assert n2() == 6
print(n2(1))
assert not n2.isDirty()
# tweaking operation applied to `n`
assert n2(1) == 2
assert not n2.isDirty()
# not permanently set
assert n2() == 6
assert not n2.isDirty()
def test_value(self):
def foo(*args):
for _ in range(5):
lazy_node.setValue(_ + 1)
yield _
lazy_node = tl.Node(value=0)
# 5 6 7 8 9
streaming_node = ts.Print(ts.Foo(foo) - 5, "streaming:")
# -5 -4 -3 -2 -1
out = ts.Print(t.LazyToStreaming(lazy_node) + 5,
"lazy:") + streaming_node
x = ts.run(out)
# 0 2 4 6 8
print(x)
assert x == [0, 2, 4, 6, 8]
def test_value_order(self):
lazy_node = tl.Node(value=0)
# 5 6 7 8 9
def foo(lazy_node=lazy_node):
for _ in range(5):
yield _
lazy_node.setValue(_ + 1)
streaming_node = ts.Print(ts.Foo(foo) - 5, "streaming:")
# -5 -4 -3 -2 -1
out = streaming_node + ts.Print(lazy_node + 5, "lazy:")
x = ts.run(out)
# 0 2 4 6 8
print(x)
assert x == [0, 2, 4, 6, 8]
def test_tweaks_dirtiness_and_parent(self):
n1 = tl.Node(value=1, name="n1")
n2 = n1 + 2
n3 = n2 + 4
assert n3({n1: -1}) == 5
assert n3() == 7
assert n3({n2: 2}) == 6
assert n3(2) == 6
assert n3(2, 2) == 4
assert n3({n1: -1}) == 5
assert n3({n1: -1}) == 5
assert n3() == 7
assert n3({n2: 2}) == 6
assert n3(2) == 6
assert n3(2, 2) == 4
assert n3({n1: -1}) == 5
assert n3() == 7
assert n3() == 7
assert n3() == 7
def test_Equal(self):
t = tl.Node(value=2)
out = tl.Equal(t, 2)
assert out()
def test_Or(self):
t = tl.Node(value=2)
out = tl.Or(t, t)
assert out() == 2
def test_And(self):
t = tl.Node(value=2)
out = tl.And(t, t)
assert out() == 2
def test_Not(self):
t = tl.Node(value=2)
out = tl.Not(t)
assert out() == False
def test_Average(self):
t = tl.Node(value=3)
out = tl.Average(t, 2, 1)
assert out() == 2
def test_Negate(self):
t = tl.Node(value=5)
out = tl.Negate(t)
assert out() == -5
def test_Le(self):
t = tl.Node(value=2)
out = tl.Le(t, 2)
assert out()
def test_NotEqual(self):
t = tl.Node(value=2)
out = tl.NotEqual(t, 1)
assert out()
def test_Ge(self):
t = tl.Node(value=2)
out = tl.Ge(t, 1)
assert out()
def test_Lt(self):
t = tl.Node(value=2)
out = tl.Lt(t, 1)
assert out() == False
def test_Pow(self):
t = tl.Node(value=3)
t2 = tl.Node(value=2)
out = tl.Pow(t, t2)
assert out() == 9
def test_Gt(self):
t = tl.Node(value=2)
out = tl.Gt(t, 2)
assert out() == False
def test_Sum(self):
t = tl.Node(value=3)
out = tl.Sum(t, t, t, 3)
assert out() == 12
import random
import tributary.lazy as t
from tributary.parser import (
parseASTForMethod,
pprintAst,
getClassAttributesUsedInMethod,
addAttributeDepsToMethodSignature,
Transformer,
pprintCode,
)
blerg = t.Node(value=5)
class Func4(t.LazyGraph):
@t.node()
def func1(self):
return self.func2() + 1
@t.node(dynamic=True)
def func2(self):
return random.random()
class Func5(t.LazyGraph):
def __init__(self):
super().__init__()
self.x = self.node(name="x", value=None)
def test_Mod(self):
t = tl.Node(value=3)
t2 = tl.Node(value=2)
out = tl.Mod(t, t2)
assert out() == 1
