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