def test_get_injectable_func_source_data():
@orca.injectable()
def inj1():
return 42
@orca.injectable(autocall=False, memoize=True)
def power(x):
return 42 ** x
def inj2():
return 'orca'
orca.add_injectable('inj2', inj2, autocall=False)
filename, lineno, source = orca.get_injectable_func_source_data('inj1')
assert filename.endswith('test_orca.py')
assert isinstance(lineno, int)
assert '@orca.injectable()' in source
filename, lineno, source = orca.get_injectable_func_source_data('power')
assert filename.endswith('test_orca.py')
assert isinstance(lineno, int)
assert '@orca.injectable(autocall=False, memoize=True)' in source
filename, lineno, source = orca.get_injectable_func_source_data('inj2')
assert filename.endswith('test_orca.py')
assert isinstance(lineno, int)
assert 'def inj2()' in source
def test_column_cache(df):
orca.add_injectable('x', 2)
series = pd.Series([1, 2, 3], index=['x', 'y', 'z'])
key = ('table', 'col')
@orca.table()
def table():
return df
@orca.column(*key, cache=True)
def column(variable='x'):
return series * variable
def c():
return orca._COLUMNS[key]
pdt.assert_series_equal(c()(), series * 2)
orca.add_injectable('x', 3)
pdt.assert_series_equal(c()(), series * 2)
c().clear_cached()
pdt.assert_series_equal(c()(), series * 3)
orca.add_injectable('x', 4)
pdt.assert_series_equal(c()(), series * 3)
orca.clear_cache()
pdt.assert_series_equal(c()(), series * 4)
orca.add_injectable('x', 5)
pdt.assert_series_equal(c()(), series * 4)
orca.get_table('table').clear_cached()
pdt.assert_series_equal(c()(), series * 5)
orca.add_injectable('x', 6)
pdt.assert_series_equal(c()(), series * 5)
orca.add_column(*key, column=column, cache=True)
pdt.assert_series_equal(c()(), series * 6)
def test_eval_step(df):
orca.add_injectable('x', 3)
@orca.step()
def step(x):
return df * x
pdt.assert_frame_equal(orca.eval_step('step'), df * 3)
pdt.assert_frame_equal(orca.eval_step('step', x=5), df * 5)
def m2(iter_var, a, b, c, iterations):
assert a == 11
if iter_var == 1000:
assert b == 22
assert c == 1033
elif iter_var == 2000:
assert b == 1022
assert c == 3033
orca.add_injectable('iterations', iterations + 1)
def test_injectable_type():
orca.add_injectable('answer', 42)
@orca.injectable()
def inj1():
return 42
@orca.injectable(autocall=False, memoize=True)
def power(x):
return 42 ** x
assert orca.injectable_type('answer') == 'variable'
assert orca.injectable_type('inj1') == 'function'
assert orca.injectable_type('power') == 'function'
def test_eval_variable(df):
orca.add_injectable('x', 3)
assert orca.eval_variable('x') == 3
@orca.injectable()
def func(x):
return 'xyz' * x
assert orca.eval_variable('func') == 'xyzxyzxyz'
assert orca.eval_variable('func', x=2) == 'xyzxyz'
@orca.table()
def table(x):
return df * x
pdt.assert_series_equal(orca.eval_variable('table.a'), df.a * 3)
def test_column_cache_disabled(df):
orca.add_injectable('x', 2)
series = pd.Series([1, 2, 3], index=['x', 'y', 'z'])
key = ('table', 'col')
@orca.table()
def table():
return df
@orca.column(*key, cache=True)
def column(x):
return series * x
def c():
return orca._COLUMNS[key]
orca.disable_cache()
pdt.assert_series_equal(c()(), series * 2)
orca.add_injectable('x', 3)
pdt.assert_series_equal(c()(), series * 3)
orca.enable_cache()
orca.add_injectable('x', 4)
pdt.assert_series_equal(c()(), series * 3)
def test_injectables_cache():
x = 2
@orca.injectable(autocall=True, cache=True)
def inj():
return x * x
def i():
return orca._INJECTABLES['inj']
assert i()() == 4
x = 3
assert i()() == 4
i().clear_cached()
assert i()() == 9
x = 4
assert i()() == 9
orca.clear_cache()
assert i()() == 16
x = 5
assert i()() == 16
orca.add_injectable('inj', inj, autocall=True, cache=True)
assert i()() == 25
def test_injectables():
orca.add_injectable('answer', 42)
@orca.injectable()
def func1(answer):
return answer * 2
@orca.injectable('func2', autocall=False)
def asdf(variable='x'):
return variable / 2
@orca.injectable()
def func3(func2):
return func2(4)
@orca.injectable()
def func4(func='func1'):
return func / 2
assert orca._INJECTABLES['answer'] == 42
assert orca._INJECTABLES['func1']() == 42 * 2
assert orca._INJECTABLES['func2'](4) == 2
assert orca._INJECTABLES['func3']() == 2
assert orca._INJECTABLES['func4']() == 42
assert orca.get_injectable('answer') == 42
assert orca.get_injectable('func1') == 42 * 2
assert orca.get_injectable('func2')(4) == 2
assert orca.get_injectable('func3') == 2
assert orca.get_injectable('func4') == 42
with pytest.raises(KeyError):
orca.get_injectable('asdf')
assert set(orca.list_injectables()) == \
{'answer', 'func1', 'func2', 'func3', 'func4'}
def test_collect_variables(df):
orca.add_table('df', df)
@orca.table()
def df_func():
return df
@orca.column('df')
def zzz():
return df['a'] / 2
orca.add_injectable('answer', 42)
@orca.injectable()
def injected():
return 'injected'
@orca.table('source table', cache=True)
def source():
return df
with pytest.raises(KeyError):
orca._collect_variables(['asdf'])
with pytest.raises(KeyError):
orca._collect_variables(names=['df'], expressions=['asdf'])
names = ['df', 'df_func', 'answer', 'injected', 'source_label', 'df_a']
expressions = ['source table', 'df.a']
things = orca._collect_variables(names, expressions)
assert set(things.keys()) == set(names)
assert isinstance(things['source_label'], orca.DataFrameWrapper)
pdt.assert_frame_equal(things['source_label'].to_frame(), df)
assert isinstance(things['df_a'], pd.Series)
pdt.assert_series_equal(things['df_a'], df['a'])
def test_table_func_cache(df):
orca.add_injectable('x', 2)
@orca.table(cache=True)
def table(variable='x'):
return df * variable
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 2)
orca.add_injectable('x', 3)
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 2)
orca.get_table('table').clear_cached()
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 3)
orca.add_injectable('x', 4)
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 3)
orca.clear_cache()
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 4)
orca.add_injectable('x', 5)
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 4)
orca.add_table('table', table)
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 5)
def test_cache_scope(df):
orca.add_injectable('x', 11)
orca.add_injectable('y', 22)
orca.add_injectable('z', 33)
orca.add_injectable('iterations', 1)
@orca.injectable(cache=True, cache_scope='forever')
def a(x):
return x
@orca.injectable(cache=True, cache_scope='iteration')
def b(y):
return y
@orca.injectable(cache=True, cache_scope='step')
def c(z):
return z
@orca.step()
def m1(iter_var, a, b, c):
orca.add_injectable('x', iter_var + a)
orca.add_injectable('y', iter_var + b)
orca.add_injectable('z', iter_var + c)
assert a == 11
@orca.step()
def m2(iter_var, a, b, c, iterations):
assert a == 11
if iter_var == 1000:
assert b == 22
assert c == 1033
elif iter_var == 2000:
assert b == 1022
assert c == 3033
orca.add_injectable('iterations', iterations + 1)
orca.run(['m1', 'm2'], iter_vars=[1000, 2000])
def test_table_func_cache_disabled(df):
orca.add_injectable('x', 2)
@orca.table('table', cache=True)
def asdf(x):
return df * x
orca.disable_cache()
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 2)
orca.add_injectable('x', 3)
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 3)
orca.enable_cache()
orca.add_injectable('x', 4)
pdt.assert_frame_equal(orca.get_table('table').to_frame(), df * 3)
def test_injectables_cm():
orca.add_injectable('a', 'a')
orca.add_injectable('b', 'b')
orca.add_injectable('c', 'c')
with orca.injectables():
assert orca._INJECTABLES == {
'a': 'a', 'b': 'b', 'c': 'c'
}
with orca.injectables(c='d', x='x', y='y', z='z'):
assert orca._INJECTABLES == {
'a': 'a', 'b': 'b', 'c': 'd',
'x': 'x', 'y': 'y', 'z': 'z'
}
assert orca._INJECTABLES == {
'a': 'a', 'b': 'b', 'c': 'c'
}
def m1(iter_var, a, b, c):
orca.add_injectable('x', iter_var + a)
orca.add_injectable('y', iter_var + b)
orca.add_injectable('z', iter_var + c)
assert a == 11
def test_is_injectable():
orca.add_injectable('answer', 42)
assert orca.is_injectable('answer') is True
assert orca.is_injectable('nope') is False
