def test_enter_exit(self):
try:
with sc.SanityChecker('algo_test', debug=True) as s:
self.assertEqual(True, isinstance(s, sc.SanityChecker))
self.assertEqual(
s.tests, {test_name: None
for test_name in sc.TESTS_NAMES})
s.tests['regular'] = {'base': True}
s.tests['naninf'] = {'': False}
s.tests_suppressed.add('dtype_object')
self.assertTrue(
False,
'sc.SanityChecker must throw YaUberSanityCheckError on __exit__'
)
except YaUberSanityCheckError:
pass
# Just for debug line
with sc.SanityChecker('algo_test', debug=True) as s:
self.assertEqual(True, isinstance(s, sc.SanityChecker))
self.assertEqual(s.tests,
{test_name: None
for test_name in sc.TESTS_NAMES})
for t_name in sc.TESTS_NAMES:
s.tests_suppressed.add(t_name)
def test_check_regular(self):
with patch('yauber_algo.sanitychecks.SanityChecker.series_compare'
) as mock_series_compare:
with patch('yauber_algo.sanitychecks.SanityChecker.report_test'
) as mock_report_test:
mock_func = MagicMock()
s = sc.SanityChecker('algo_test', debug=True).__enter__()
expected = np.array([1, 2, 3, 4, 5, 6], dtype=np.float)
result = np.array([10, 20, 30, 40, 50, 60], dtype=np.float)
mock_func.return_value = result
# Default args
s.check_regular(expected, mock_func, suffix='test')
self.assertEqual(mock_func.called, True)
self.assertEqual(mock_func.call_args[0], ())
self.assertEqual(mock_func.call_args[1], {})
# Custom args
s.check_regular(expected,
mock_func, (1, ), {'test': True},
suffix='test')
self.assertEqual(mock_func.called, True)
self.assertEqual(mock_func.call_args[0], (1, ))
self.assertEqual(mock_func.call_args[1], {'test': True})
self.assertEqual(mock_series_compare.called, True)
self.assertEqual(mock_series_compare.call_args[0],
(result, expected))
self.assertEqual(mock_report_test.call_args[0],
('regular', 'test', True))
def test_supress_test(self):
s = sc.SanityChecker('algo_test', debug=True)
self.assertEqual(s.tests_suppressed, set())
s.suppress_test('futref')
self.assertEqual(True, 'futref' in s.tests_suppressed)
self.assertRaises(ValueError, s.suppress_test,
'some_unknown_test_name')
def test_report_test(self):
s = sc.SanityChecker('test')
self.assertRaises(YaUberSanityCheckError, s.report_test, 'test',
'test', True)
s.tests['test'] = None
s.report_test('test', 'test', True)
s.report_test('test', 'test2', True)
self.assertRaises(YaUberSanityCheckError, s.report_test, 'test',
'test', True)
self.assertEqual(s.tests, {'test': {'test': True, 'test2': True}})
def test_check_series(self):
with patch('yauber_algo.sanitychecks.SanityChecker.series_compare'
) as mock_series_compare:
with patch('yauber_algo.sanitychecks.SanityChecker.report_test'
) as mock_report_test:
mock_func = MagicMock()
s = sc.SanityChecker('algo_test', debug=True).__enter__()
expected = np.array([1, 2, 3, 4, 5, 6], dtype=np.float)
result = np.array([10, 20, 30, 40, 50, 60], dtype=np.float)
mock_func.return_value = pd.Series(result)
# Default args
s.check_series(expected, mock_func, suffix='test')
self.assertEqual(mock_func.called, True)
self.assertEqual(mock_func.call_args[0], ())
self.assertEqual(mock_func.call_args[1], {})
# Custom args
s.check_series(expected,
mock_func, (1, ), {'test': True},
suffix='test')
self.assertEqual(mock_func.called, True)
self.assertEqual(mock_func.call_args[0], (1, ))
self.assertEqual(mock_func.call_args[1], {'test': True})
self.assertEqual(mock_series_compare.called, True)
self.assertEqual(len(mock_series_compare.call_args[0]), 2)
self.assertEqual(
True,
np.all(
mock_series_compare.call_args[0][0].values == result))
self.assertEqual(
True,
np.all(mock_series_compare.call_args[0][1] == expected))
self.assertEqual(mock_report_test.call_args[0],
('series', 'test', True))
# Assert must be series
mock_func.return_value = result
self.assertRaises(AssertionError,
s.check_series,
expected,
mock_func, (1, ), {'test': True},
suffix='test')
def test_check_dtype_int(self):
with patch('yauber_algo.sanitychecks.SanityChecker.check_dtype_generic'
) as mock_check_dtype_generic:
s = sc.SanityChecker('algo_test').__enter__()
mock_func = MagicMock()
expected = np.array([1, 2, 3, 4, 5, 6], dtype=np.float)
s.check_dtype_int(expected,
mock_func, (1, ), {'test': True},
suffix='test')
self.assertEqual(
(np.int32, 'dtype_int', expected, mock_func, (1, ), {
'test': True
}), mock_check_dtype_generic.call_args[0])
self.assertEqual({'suffix': 'test'},
mock_check_dtype_generic.call_args[1])
def test_check_dtype_generic(self):
with patch('yauber_algo.sanitychecks.SanityChecker.series_compare'
) as mock_series_compare:
with patch('yauber_algo.sanitychecks.SanityChecker.report_test'
) as mock_report_test:
mock_func = MagicMock()
s = sc.SanityChecker('algo_test', debug=True).__enter__()
expected = np.array([1, 2, 3, 4, 5, 6], dtype=np.float)
result = np.array([10, 20, 30, 40, 50, 60], dtype=np.float)
mock_func.return_value = result
# Default args
self.assertRaises(AssertionError,
s.check_dtype_generic,
np.float,
'float',
expected,
mock_func,
suffix='test')
self.assertEqual(mock_func.called, True)
self.assertEqual(mock_func.call_args[0], ())
self.assertEqual(mock_func.call_args[1], {})
# Custom args
input_series = np.array([np.nan, 20, 30, np.inf, 50, 60],
dtype=np.float)
s.check_dtype_generic(np.float,
'dtype_float',
expected,
mock_func, (input_series, ),
{'test': True},
suffix='test')
self.assertEqual(mock_func.called, True)
self.assertEqual(mock_func.call_args[0], (input_series, ))
self.assertEqual(mock_func.call_args[1], {'test': True})
self.assertEqual(mock_series_compare.called, True)
self.assertEqual(mock_series_compare.call_args[0],
(result, expected))
self.assertEqual(mock_report_test.call_args[0],
('dtype_float', 'test', True))
def test_check_dtype_generic_exception(self):
s = sc.SanityChecker('algo_test').__enter__()
mock_func = MagicMock()
def raise_no_object(*args, **kwargs):
raise YaUberAlgoDtypeNotSupportedError('test')
s.check_dtype_generic(np.float,
'dtype_float', (1, ),
raise_no_object, (1, ), {'test': True},
suffix='test',
exception=YaUberAlgoDtypeNotSupportedError)
# Rerise another exception
self.assertRaises(YaUberAlgoDtypeNotSupportedError,
s.check_dtype_generic,
np.float,
'dtype_float', (1, ),
raise_no_object, (1, ), {'test': True},
suffix='test',
exception=ValueError)
def test_check_dtype_object(self):
with patch('yauber_algo.sanitychecks.SanityChecker.check_dtype_generic'
) as mock_check_dtype_generic:
s = sc.SanityChecker('algo_test').__enter__()
mock_func = MagicMock()
expected = np.array([1, 2, 3, 4, 5, 6], dtype=np.float)
self.assertRaises(AssertionError,
s.check_dtype_object,
mock_func, (1, ), {'test': True},
suffix='test')
def raise_no_object(*args, **kwargs):
raise YaUberAlgoDtypeNotSupportedError('test')
mock_check_dtype_generic.side_effect = raise_no_object
s.check_dtype_object(raise_no_object, (1, ), {'test': True},
suffix='test')
self.assertEqual({'suffix': 'test'},
mock_check_dtype_generic.call_args[1])
def test_check_regular_expected_exception(self):
with patch('yauber_algo.sanitychecks.SanityChecker.series_compare'
) as mock_series_compare:
with patch('yauber_algo.sanitychecks.SanityChecker.report_test'
) as mock_report_test:
mock_func = MagicMock()
s = sc.SanityChecker('algo_test', debug=True).__enter__()
expected = np.array([1, 2, 3, 4, 5, 6], dtype=np.float)
result = np.array([10, 20, 30, 40, 50, 60], dtype=np.float)
def exception_valueerror_raised(*args, **kwargs):
raise ValueError()
mock_func.side_effect = exception_valueerror_raised
# Unexpected exception raised
self.assertRaises(ValueError,
s.check_regular,
expected,
mock_func,
suffix='test')
self.assertEqual(mock_report_test.called, False)
# Expected exception
s.check_regular(expected,
mock_func,
suffix='test',
exception=ValueError)
self.assertEqual(mock_report_test.called, True)
# Expected but not Raised by code -> Assertion error
mock_func.side_effect = lambda: result
self.assertRaises(AssertionError,
s.check_regular,
expected,
mock_func,
suffix='test',
exception=ValueError)
def test_percent_rank_category(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import apply
#
# Function settings
#
algo = 'apply'
func = apply
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling')
s.check_regular(
array([nan, nan, 6, nan, nan, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='category')
s.check_regular(
array([nan, nan, nan, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
3, # return_as_cat=
True, # exclude_nan=
),
suffix='category_ret_as_cat_number_not_exists')
s.check_regular(
None,
func,
(
np.arange(0, 101),
3,
np.sum,
np.arange(0, 101),
3, # return_as_cat=
True, # exclude_nan=
),
suffix='category_more_than_100_unique_cats',
exception=YaUberAlgoArgumentError)
s.check_regular(
array([nan, nan, 6, 6, 6, 6, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
0, # return_as_cat=
True, # exclude_nan=
),
suffix='category_exact')
s.check_regular(
array([nan, nan, 6, 6, 6, 6, 6]),
func,
(
array([3, 2, 1, nan, nan, nan, nan]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
0, # return_as_cat=
True, # exclude_nan=
),
suffix='category_ret_nan')
s.check_regular(
array([nan, nan, nan, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, 4, 1, nan, nan]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
array([1, 1, 1, 1, 1, 1, 1]), # return_as_cat=
True, # exclude_nan=
),
suffix='category_ret_nan_if_arr_nan')
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
0,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='zero_period',
exception=YaUberAlgoArgumentError,
)
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
-1,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='neg_period',
exception=YaUberAlgoArgumentError,
)
s.check_regular(
func(array([3, 2, 1, 4, 3, 2, 1]), 3, np.sum),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([1, 1, 1, 1, 1, 1, 1]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling_and_categorical_equal')
s.check_regular(
array([nan, nan, nan, nan, 8, 9, 6]),
func,
(
array([3, nan, 1, 4, 3, 2, 1]),
3,
np.sum,
None, # category=
None, # return_as_cat=
False, # exclude_nan=
),
suffix='rolling_not_exclude_nan')
#
# NAN / INF
#
#
s.check_naninf(
array([nan, nan, nan, nan, 8, 9, nan]),
func,
(
array([inf, nan, 1, 4, 3, 2, inf]),
3,
np.sum,
None, # category=
None, # return_as_cat=
False, # exclude_nan=
),
suffix='rolling')
s.check_naninf(
array([nan, nan, 1, 5, 8, 9, nan]),
func,
(
array([inf, nan, 1, 4, 3, 2, inf]),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling_naninf_excluded')
s.check_series(
pd.Series(array([nan, nan, 6, 7, 8, 9, 6])),
func,
(
pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling')
s.check_series(
pd.Series(array([nan, nan, 6, 7, 8, 9, 6])),
func,
(
pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
3,
np.sum,
pd.Series(array([0, 0, 0, 0, 0, 0, 0])), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='categorical')
s.check_series(
pd.Series(array([nan, nan, 6, 7, 8, 9, 6])),
func,
(
pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
3,
np.sum,
pd.Series(array([0, 0, 0, 0, 0, 0, 0])), # category=
pd.Series(array([0, 0, 0, 0, 0, 0, 0])), # return_as_cat=
True, # exclude_nan=
),
suffix='categorical_ret_as')
s.check_regular(
array([nan, nan, 6, 7, nan, nan, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='categorical')
s.check_naninf(
array([nan, nan, 6, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, nan, 3, 2, inf]),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='categorical')
s.check_naninf(
array([nan, nan, 6, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, 2, 3, 2, 4]),
3,
np.sum,
array([0, 0, 0, inf, 1, 1, nan]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='nan_for_category')
s.check_naninf(
array([nan, nan, 6, 6, 6, 6, 6]),
func,
(
array([3, 2, 1, 2, 3, 2, 4]),
3,
np.sum,
array([0, 0, 0, inf, 1, 1, nan]), # category=
0, # return_as_cat=
True, # exclude_nan=
),
suffix='return_as_cat_ignore_codex',
ignore_nan_argument_position_check=True,
)
s.check_naninf(
array([nan, nan, nan, nan, nan, 6, 6]),
func,
(
array([3, 2, 1, 2, 3, 2, nan]),
3,
np.sum,
array([0, 0, 1, inf, 1, 1, nan]), # category=
1, # return_as_cat=
True, # exclude_nan=
),
suffix='return_as_cat_non_NAN_if_reference_with_valid_window',
ignore_nan_argument_position_check=True,
)
s.check_naninf(
array([nan, nan, nan, nan, nan, 6, nan]),
func,
(
array([3, 2, 1, 2, 3, 2, nan]),
3,
np.sum,
array([0, 0, 1, inf, 1, 1, 1]), # category=
1, # return_as_cat=
True, # exclude_nan=
),
suffix='return_as_cat_NOT_ignore_codex_if_same_cat',
)
s.check_naninf(
array([nan, nan, nan, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, 2, 3, 2, nan]),
3,
np.sum,
array([0, 0, 1, inf, 1, 1, nan]), # category=
0, # return_as_cat=
True, # exclude_nan=
),
suffix='return_as_cat_widows_less_period',
)
s.check_dtype_float(
array([nan, nan, 6, 7, 8, 9, 6], dtype=np.float),
func,
(
array([3, 2, 1, 4, 3, 2, 1], dtype=np.float),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling')
s.check_dtype_float(
array([nan, nan, 6, 5, nan, nan, 9], dtype=np.float),
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.float),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.float), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='category')
s.check_dtype_float(
array([nan, nan, 6, 5, 5, 5, 5], dtype=np.float),
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.float),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.float), # category=
array([0, 0, 0, 0, 0, 0, 0], dtype=np.float),
True, # exclude_nan=
),
suffix='category_ret_as')
s.check_dtype_bool(
array([nan, nan, 3, 3, 3, 3, 3], dtype=np.float),
func,
(
array([1, 1, 1, 1, 1, 1, 1], dtype=np.bool),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling')
s.check_dtype_bool(
array([nan, nan, 3, 3, nan, nan, 3], dtype=np.float),
func,
(
array([1, 1, 1, 1, 1, 1, 1], dtype=np.bool),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.bool), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='category')
s.check_dtype_bool(
array([nan, nan, 6, 5, 5, 5, 5], dtype=np.float),
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.float),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.bool), # category=
array([0, 0, 0, 0, 0, 0, 0], dtype=np.bool),
True, # exclude_nan=
),
suffix='category_ret_as')
s.check_dtype_int(
array([nan, nan, 6, 7, 8, 9, 6], dtype=np.float),
func,
(
array([3, 2, 1, 4, 3, 2, 1], dtype=np.int32),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling')
s.check_dtype_int(
array([nan, nan, 6, 5, nan, nan, 9], dtype=np.float),
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.int32),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.int32), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='category')
s.check_dtype_int(
array([nan, nan, 6, 5, 5, 5, 5], dtype=np.float),
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.float),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.int32), # category=
array([0, 0, 0, 0, 0, 0, 0], dtype=np.int32),
True, # exclude_nan=
),
suffix='category_ret_as')
s.check_dtype_object(
func,
(
array([3, 2, 1, 4, 3, 2, 1], dtype=np.object),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling')
s.check_dtype_object(
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.object),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.object), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='category')
s.check_dtype_object(
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.float),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.float), # category=
array([0, 0, 0, 0, 0, 0, 0], dtype=np.object),
True, # exclude_nan=
),
suffix='category_ret_as')
s.check_futref(5,
1,
func, (
np.random.random(100),
5,
np.sum,
),
suffix='rolling')
s.check_window_consistency(5,
1,
func, (
np.random.random(100),
5,
np.sum,
),
suffix='rolling')
s.check_futref(5,
1,
func, (
np.random.random(100),
5,
np.sum,
np.random.random_integers(0, 3, 100),
),
suffix='category')
s.check_window_consistency(
5,
1,
func, (
np.random.random(100),
5,
np.sum,
np.random.random_integers(0, 3, 100),
),
suffix='category')
s.check_futref(5,
1,
func, (
np.random.random(100),
5,
np.sum,
np.random.random_integers(0, 3, 100),
np.random.random_integers(0, 3, 100),
),
suffix='category_ret_as')
s.check_window_consistency(
5,
1,
func, (
np.random.random(100),
5,
np.sum,
np.random.random_integers(0, 3, 100),
np.random.random_integers(0, 3, 100),
),
suffix='category_ret_as')
def test_categorize(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import categorize
#
# Function settings
#
algo = 'categorize'
func = categorize
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
np.array([0., 0., 0., 0., 1., 1., 1., 2., 2., 2.]),
func,
(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0, 3, 6, 10]),
suffix='reg')
s.check_regular(
np.array([0., 0., 0., 0., 1., 1., 1., 2., 2., 2.]),
func,
(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0.1, 3, 6, 10]),
suffix='min_not_in_bins',
exception=YaUberAlgoInternalError)
s.check_regular(
np.array([0., 0., 0., 0., 1., 1., 1., 2., 2., 2.]),
func,
(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0, 3, 6, 9.999]),
suffix='max_not_in_bins',
exception=YaUberAlgoInternalError)
s.check_regular(
np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0, 10]),
suffix='min_max_one_bin',
exception=YaUberAlgoArgumentError)
s.check_regular(
np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0, 10, 10]),
suffix='bins_non_unique',
exception=YaUberAlgoArgumentError)
s.check_regular(
np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0, 10, 5]),
suffix='bins_not_sorted',
exception=YaUberAlgoArgumentError)
s.check_regular(
np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
func,
(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0, 5, 'obj']),
suffix='bins_non_number',
exception=YaUberAlgoArgumentError)
s.check_regular(
np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0, 5, nan]),
suffix='bins_nan',
exception=YaUberAlgoArgumentError)
s.check_regular(
np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]), [0, 5, inf]),
suffix='bins_inf',
exception=YaUberAlgoArgumentError)
s.check_naninf(
np.array([0., 0., 0., 0., 1., 1., 1., 2., nan, nan]),
func,
(np.array([0, 1, 2, 3, 4, 5, 6, 7, inf, nan]), [0, 3, 6, 10]),
suffix='reg')
s.check_regular(np.array([0., 0., 0., 0., 1., 1., 1., 2., 2., 2.]),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10
]), np.array([0, 3, 6, 10])),
suffix='bins_are_np_array')
s.check_regular(np.array([0., 0., 0., 0., 1., 1., 1., 2., 2., 2.]),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10
]), pd.Series([0, 3, 6, 10])),
suffix='bins_are_series')
s.check_series(pd.Series(
np.array([0., 0., 0., 0., 1., 1., 1., 2., 2., 2.])),
func,
(pd.Series(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10
])), [0, 3, 6, 10]),
suffix='')
s.check_dtype_float(
np.array([0., 0., 0., 0., 1., 1., 1., 2., 2., 2.],
dtype=np.float),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10],
dtype=np.float), [0, 3, 6, 10]),
suffix='')
s.check_dtype_int(np.array(
[0., 0., 0., 0., 1., 1., 1., 2., 2., 2.], dtype=np.float),
func, (np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10],
dtype=np.int32), [0, 3, 6, 10]),
suffix='')
s.check_dtype_bool(np.array(
[0., 0., 0., 0., 1., 1., 1., 2., 2., 2.], dtype=np.float),
func, (np.array([0, 1, 0, 0, 1, 0, 1, 0, 0, 1],
dtype=np.bool), [0, 3, 6, 10]),
suffix='',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_object(func,
(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 10],
dtype=np.object), [0, 3, 6, 10]),
suffix='')
s.check_futref(
5,
1,
func,
(np.random.random(1000), [0, 0.33, 0.66, 1.0]),
)
s.check_window_consistency(
5,
1,
func,
(np.random.random(1000), [0, 0.33, 0.66, 1.0]),
)
def test_rangeclose(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import rangeclose
import yauber_algo.algo as a
#
# Function settings
#
algo = 'rangeclose'
func = rangeclose
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([0.8]),
func,
(
array([10]), # h
array([0]), # l
array([8]), # c
1),
suffix='uptrend')
s.check_regular(
array([0.8]),
func,
(
array([10]), # h
array([0]), # l
array([8]), # c
0),
suffix='period_zero',
exception=YaUberAlgoArgumentError)
s.check_regular(
array([0.4]),
func,
(
array([10]), # h
array([0]), # l
array([8]), # c
-1),
suffix='period_negative',
exception=YaUberAlgoArgumentError)
s.check_regular(
array([0.4]),
func,
(
array([10]), # h
array([0]), # l
array([11]), # c
1),
suffix='close_gt_hi',
exception=YaUberAlgoInternalError)
s.check_regular(
array([0.4]),
func,
(
array([10]), # h
array([0]), # l
array([-1]), # c
1),
suffix='close_lt_lo',
exception=YaUberAlgoInternalError)
s.check_regular(
array([0.2]),
func,
(
array([10]), # h
array([0]), # l
array([2]), # c
1),
suffix='dn_trend')
s.check_regular(
array([0.5]),
func,
(
array([10]), # h
array([0]), # l
array([5]), # c
1),
suffix='neutral_trend')
s.check_regular(
array([0.4]),
func,
(
array([0]), # h
array([10]), # l
array([2]), # c
1),
suffix='sanity_h_less_l',
exception=YaUberAlgoInternalError)
s.check_regular(
array([0.5]),
func,
(
array([10]), # h
array([0]), # l
array([5]), # c
1),
suffix='doji')
s.check_regular(
array([0.5]),
func,
(
array([10]), # h
array([0]), # l
array([5]), # c
1),
suffix='doji_h_eq_l')
s.check_regular(
array([1.0]),
func,
(
array([10]), # h
array([0]), # l
array([10]), # c
1),
suffix='ideal_trend_up')
s.check_regular(
array([0.0]),
func,
(
array([10]), # h
array([0]), # l
array([0]), # c
1),
suffix='ideal_trend_dn')
s.check_regular(
array([0.5]),
func,
(
array([10]), # h
array([10]), # l
array([10]), # c
1),
suffix='flat_candle')
s.check_regular(
array([nan]),
func,
(
array([nan]), # h
array([10]), # l
array([10]), # c
1),
suffix='nan_h')
s.check_regular(
array([nan]),
func,
(
array([10]), # h
array([nan]), # l
array([10]), # c
1),
suffix='nan_l')
s.check_regular(
array([nan]),
func,
(
array([10]), # h
array([10]), # l
array([nan]), # c
1),
suffix='nan_c')
s.check_regular(
array([nan, 0.5]),
func,
(
array([6, 10]), # h
array([0, 3]), # l
array([0, 5]), # c
2),
suffix='period2')
s.check_regular(
array([nan, 1.0]),
func,
(
array([10, 10]), # h
array([0, 3]), # l
array([0, 10]), # c
2),
suffix='period2_alt')
s.check_regular(
array([nan, 1.0, (7 - 0.0) / (20 - 0)]),
func,
(
array([10, 10, 20]), # h
array([0, 3, 0]), # l
array([0, 10, 7]), # c
2),
suffix='period2_alt_n3')
s.check_regular(
array([nan, nan, (7 - 0) / (20 - 0)]),
func,
(
array([10, 10, 20]), # h
array([0, nan, 0]), # l
array([0, 10, 7]), # c
2),
suffix='period2_alt_n3_llv_nan')
s.check_regular(
array([nan, (5 - 0) / (10 - 0), (2 - 0) / (5 - 0)]),
func,
(
array([10, 5, 2]), # h
array([0, 3, 0]), # l
array([0, 5, 2]), # c
2),
suffix='period2_alt_n3_hhv')
s.check_regular(
array([nan, nan, 0.7]),
func,
(
array([10, nan, 10]), # h
array([0, 3, 0]), # l
array([0, 10, 7]), # c
2),
suffix='period2_alt_n3_hhv_with_nan')
s.check_naninf(
array([nan, 0.5]),
func,
(
array([nan, 10]), # h
array([inf, 0]), # l
array([nan, 5]), # c
2),
suffix='period2_nan_ignored',
)
s.check_series(
pd.Series(array([nan, 0.5])),
func,
(
pd.Series(array([6, 10])), # h
pd.Series(array([0, 3])), # l
pd.Series(array([0, 5])), # c
2),
suffix='series')
s.check_dtype_float(
array([0.8], dtype=np.float),
func,
(
array([10], dtype=np.float), # h
array([0], dtype=np.float), # l
array([8], dtype=np.float), # c
1),
)
s.check_dtype_int(
array([0.8], dtype=np.float),
func,
(
array([10], dtype=np.int32), # h
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
1),
)
s.check_dtype_bool(
array([0.8], dtype=np.float),
func,
(
array([2], dtype=np.bool), # o
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
1),
suffix='bool_h',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_bool(
array([0.4], dtype=np.float),
func,
(
array([0], dtype=np.int32), # l
array([2], dtype=np.bool), # o
array([8], dtype=np.int32), # c
1),
suffix='bool_l',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_bool(
array([0.4], dtype=np.float),
func,
(
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
array([2], dtype=np.bool), # o
1),
suffix='bool_c',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_object(
func,
(
array([2], dtype=np.object), # o
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
1),
suffix='bool_o',
)
# Check with manual formula
h = l = c = o = np.random.random(1000)
rclose = (c - a.llv(l, 20)) / (a.hhv(h, 20) - a.llv(l, 20))
s.check_regular(rclose, func, (h, l, c, 20), suffix='formula')
s.check_futref(
5,
1,
func,
(
np.random.random_integers(60, 100, 100), # h
np.random.random_integers(0, 30, 100), # l
np.random.random_integers(31, 59, 100), # c
5),
)
s.check_window_consistency(
5,
1,
func,
(
np.random.random_integers(60, 100, 100), # h
np.random.random_integers(0, 30, 100), # l
np.random.random_integers(31, 59, 100), # c
5),
)
def test_hhv(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import hhv
#
# Function settings
#
algo = 'hhv'
func = hhv
hhv_arr3 = array([0, 0, nan, 1])
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([nan, nan, 7, 6, 5, 4, 3]),
func,
(
array([7, 6, 5, 4, 3, 2, 1]),
3
),
suffix='decreasing'
)
s.check_regular(
array([nan, nan, 7, 6, 5, 4, 3]),
func,
(
array([7, 6, 5, 4, 3, 2, 1]),
-3
),
suffix='negative_period',
exception=YaUberAlgoArgumentError
)
s.check_regular(
array([nan, nan, 3, 4, 5, 6, 7]),
func,
(
array([1, 2, 3, 4, 5, 6, 7]),
3
),
suffix='increasing'
)
s.check_regular(
array([nan, nan, nan, 1]),
func,
(
array([0, 0, nan, 1]),
3
),
suffix='with_nan'
)
s.check_regular(
array([nan, nan, nan, 1]), # Expected
func,
(
array([nan, nan, nan, 1]), # Input array
3
),
suffix='with_nan2'
)
s.check_regular(
array([nan, nan, nan, nan]), # Expected
func,
(
array([0, nan, nan, nan]), # Input array
3
),
suffix='with_nan3'
)
s.check_naninf(
array([nan, nan, nan, nan]), # Expected
func,
(
array([inf, 0, -inf, nan]), # Input array
3
),
suffix='pos_inf'
)
s.check_naninf(
array([nan, nan, nan, nan]), # Expected
func,
(
array([-inf, 0, inf, nan]), # Input array
3
),
suffix='neg_inf'
)
s.check_series(
pd.Series(array([nan, nan, 3, 4, 5, 6, 7])),
func,
(
pd.Series(array([1, 2, 3, 4, 5, 6, 7])),
3
),
)
s.check_dtype_float(
array([nan, nan, 3, 4, 5, 6, 7], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6, 7], dtype=np.float),
3
),
)
s.check_dtype_bool(
array([nan, nan, 1, 1, 1, 0, 1], dtype=np.float),
func,
(
array([False, False, True, False, False, False, True], dtype=np.bool),
3
),
)
s.check_dtype_int(
array([nan, nan, 3, 4, 5, 6, 7], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6, 7], dtype=np.int32),
3
),
)
s.check_dtype_object(
func,
(
array([1, 2, 3, 4, 5, 6, 7], dtype=np.object),
3
),
)
s.check_futref(5, 1,
func, (sc.SAMPLE_10_FLOAT, 3),
min_checks_count=3,
)
s.check_window_consistency(5, 1,
func, (sc.SAMPLE_10_FLOAT, 3),
min_checks_count=3,
)
def test_percent_rank_category(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import percent_rank_category, percent_rank
#
# Function settings
#
algo = 'percent_rank_category'
func = percent_rank_category
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(array([nan, nan, nan, nan, nan, .30, .10]),
func, (array([3, 2, 1, 4, 3, 2, 1
]), array([1, 1, 1, 1, 1, 1, 1]), 5),
suffix='reg')
s.check_regular(array(
[nan, nan, nan, nan, nan, .50, nan, nan, nan, nan, nan, 1.00]),
func,
(array([5, 5, 5, 5, 5, 5, 1, 2, 3, 4, 5, 6]),
array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]), 5),
suffix='reg_category')
s.check_regular(
array([
nan, nan, nan, nan, nan, .50, nan, nan, nan, nan, nan, 1.00
]),
func,
(array([5, 5, 5, 5, 5, 5, 1, 2, 3, 4, 5, 6
]), array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]), 4),
suffix='error_period_less_5',
exception=YaUberAlgoInternalError,
)
s.check_regular(
array([
nan, nan, nan, nan, nan, .50, nan, nan, nan, nan, nan, 1.00
]),
func,
(array([5, 5, 5, 5, 5, 5, 1, 2, 3, 4, 5, 6
]), array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]), 0),
suffix='error_period_zero',
exception=YaUberAlgoArgumentError,
)
s.check_regular(
array([
nan, nan, nan, nan, nan, .50, nan, nan, nan, nan, nan, 1.00
]),
func,
(array([5, 5, 5, 5, 5, 5, 1, 2, 3, 4, 5, 6
]), array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]), -1),
suffix='error_period_negative',
exception=YaUberAlgoArgumentError,
)
s.check_regular(
None,
func,
(
np.arange(0, 101),
np.arange(0, 101),
3, # return_as_cat=
),
suffix='category_more_than_100_unique_cats',
exception=YaUberAlgoArgumentError)
s.check_regular(
array([
nan, nan, nan, nan, nan, .50, nan, nan, nan, nan, nan, nan,
1.00
]),
func, (array([5, 5, 5, 5, 5, 5, 1, 2, 3, 4, 5, 6, 6]),
array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, nan, 0]), 5),
suffix='reg_category_nan_skipped')
rand_data = np.random.random(100)
s.check_regular(percent_rank(rand_data, 5),
func, (rand_data, np.ones(100), 5),
suffix='same_as_plain_rank')
rand_data = np.random.random(100)
rand_data[25] = nan
rand_data[49] = inf
rand_data[59] = -inf
s.check_naninf(percent_rank(rand_data, 5),
func, (rand_data, np.ones(100), 5),
suffix='same_nan_inf_handling')
s.check_series(pd.Series(array([nan, nan, nan, nan, nan, .30,
.10])),
func, (pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
pd.Series(array([1, 1, 1, 1, 1, 1, 1])), 5),
suffix='reg')
s.check_dtype_float(
array([nan, nan, nan, nan, nan, .30, .10], dtype=np.float),
func, (array([3, 2, 1, 4, 3, 2, 1], dtype=np.float),
array([1, 1, 1, 1, 1, 1, 1], dtype=np.float), 5),
suffix='reg')
s.check_dtype_int(
array([nan, nan, nan, nan, nan, .30, .10], dtype=np.float),
func, (array([3, 2, 1, 4, 3, 2, 1], dtype=np.int32),
array([1, 1, 1, 1, 1, 1, 1], dtype=np.int32), 5),
suffix='reg')
s.check_dtype_bool(
array([nan, nan, nan, nan, nan, .20, .70], dtype=np.float),
func, (array([0, 1, 1, 0, 1, 0, 1], dtype=np.bool),
array([1, 1, 1, 1, 1, 1, 1], dtype=np.bool), 5),
suffix='reg')
s.check_dtype_object(
func, (array([0, 1, 1, 0, 1, 0, 1], dtype=np.object),
array([1, 1, 1, 1, 1, 1, 1], dtype=np.object), 5),
suffix='reg')
s.check_futref(
5,
1,
func,
(np.random.random(100), np.random.random_integers(0, 3,
100), 5),
)
s.check_window_consistency(
5,
1,
func,
(np.random.random(100), np.random.random_integers(0, 3,
100), 5),
)
def test_lowest_since(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import lowest_since
#
# Function settings
#
algo = 'lowest_since'
func = lowest_since
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([nan, 2, 2, 4, 4, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
),
suffix='cond_increasing')
s.check_regular(
array([nan, 5, 4, 3, 2, 1], dtype=np.float),
func,
(
array([6, 5, 4, 3, 2, 1], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
),
suffix='cond_decreasing')
s.check_regular(
array([nan, 5, 4, nan, 2, 1], dtype=np.float),
func,
(
array([6, 5, 4, 3, 2, 1], dtype=np.float), # arr
array([0, 1, 0, nan, 0, 1], dtype=np.float), # cond
),
suffix='cond_nan')
s.check_regular(
array([nan, 2, 2, nan, 2, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, 0, nan, 0, 1], dtype=np.float), # cond
),
suffix='cond_incr')
s.check_regular(
array([nan, 2, 2, nan, 2, 6], dtype=np.float),
func,
(
array([1, 2, 3, nan, 5, 6], dtype=np.float), # arr
array([0, 1, 0, nan, 0, 1], dtype=np.float), # cond
),
suffix='cond_arr_nan')
s.check_regular(
array([nan, 2, 2, nan, 5, 6], dtype=np.float),
func,
(
array([1, 2, 3, nan, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
),
suffix='arr_nan_at_cond')
s.check_regular(
array([nan, nan, 3, nan, 5, 6], dtype=np.float),
func,
(
array([nan, nan, 3, nan, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
),
suffix='arr_nan_at_cond2')
s.check_regular(
array([nan, 2, 2, 1, nan, nan], dtype=np.float),
func,
(
array([1, 2, 3, 1, nan, nan], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
),
suffix='arr_nan_skipped')
s.check_regular(
array([nan, 2, 2, nan, 2, 6], dtype=np.float),
func,
(
array([1, 2, 3, 0, 3, 6], dtype=np.float), # arr
array([0, 1, 0, nan, 0, 1], dtype=np.float), # cond
),
suffix='cond_nan_skipped')
s.check_regular(
array([nan, 2, 3, 1, 1, nan], dtype=np.float),
func,
(
array([1, inf, -inf, 1, nan, nan], dtype=np.float), # arr
array([0, 1, inf, 1, 0, 1], dtype=np.float), # cond
),
suffix='cond_non_bool_inf',
exception=YaUberAlgoInternalError,
)
s.check_regular(
array([nan, 2, 3, 1, 1, nan], dtype=np.float),
func,
(
array([1, inf, -inf, 1, nan, nan], dtype=np.float), # arr
array([0, 1, 0, 1, 2, 1], dtype=np.float), # cond
),
suffix='cond_non_binary',
exception=YaUberAlgoInternalError,
)
s.check_naninf(
array([nan, nan, nan, 1, nan, nan], dtype=np.float),
func,
(
array([1, inf, -inf, 1, nan, nan], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
),
suffix='inf_replaced')
s.check_naninf(
array([nan, nan, 2, nan, nan, nan], dtype=np.float),
func,
(
array([1, inf, 2, inf, nan, nan], dtype=np.float), # arr
array([0, 1, 0, 0, 0, 1], dtype=np.float), # cond
),
suffix='number_is_greater')
s.check_naninf(
array([nan, nan, 2, nan, nan, nan], dtype=np.float),
func,
(
array([nan, inf, 2, 3, 4, 5], dtype=np.float), # arr
array([0, 1, 0, nan, nan, nan], dtype=np.float), # cond
),
suffix='cond_nan_replaced')
s.check_naninf(
array([nan, nan, 2, nan, nan, nan], dtype=np.float),
func,
(
array([1, -inf, 2, -inf, nan, nan], dtype=np.float), # arr
array([0, 1, 0, 0, 0, 1], dtype=np.float), # cond
),
suffix='number_is_greater_neg')
s.check_series(
pd.Series(array([nan, 2, 2, 4, 4, 6], dtype=np.float)),
func,
(
pd.Series(array([1, 2, 3, 4, 5, 6],
dtype=np.float)), # arr
pd.Series(array([0, 1, 0, 1, 0, 1],
dtype=np.float)), # cond
),
suffix='ser')
s.check_dtype_float(
array([nan, 2, 2, 4, 4, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
),
suffix='')
s.check_dtype_int(
array([nan, 2, 2, 4, 4, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.int32), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.int32), # cond
),
suffix='')
s.check_dtype_bool(
array([nan, 2, 2, 4, 4, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.int32), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.bool), # cond
),
suffix='')
s.check_dtype_bool(
array([nan, 1, 1, 0, 0, 1], dtype=np.float),
func,
(
array([1, 1, 1, 0, 1, 1], dtype=np.bool), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.bool), # cond
),
suffix='both_bool')
s.check_dtype_object(
func,
(
array([1, 1, 1, 0, 1, 1], dtype=np.bool), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.object), # cond
),
)
s.check_futref(
5,
1,
func,
(
array([1, 2, 3, 4, 5, 6, 0, 0, 0, 1],
dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
dtype=np.float), # cond
),
min_checks_count=3,
)
s.check_window_consistency(
5,
1,
func,
(
array([1, 2, 3, 4, 5, 6, 0, 0, 0, 1],
dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
dtype=np.float), # cond
),
min_checks_count=3,
)
def test_zscore(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import zscore
#
# Function settings
#
algo = 'zscore'
func = zscore
def zsc(arr):
return (arr[-1] - np.mean(arr)) / np.std(arr)
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
a = array([3, 2, 1, 4, 3, 2, 1])
s.check_regular(array(
[nan, nan, nan, nan,
zsc(a[0:5]),
zsc(a[1:6]),
zsc(a[2:7])]),
func, (a, 5),
suffix='match_with_numpy')
a = array([1, 1, 1, 1, 1, 1, 1])
s.check_regular(array([nan, nan, nan, nan, 0, 0, 0]),
func, (a, 5),
suffix='zscore_no_disp_is_zero')
a = array([3, 2, 1, 4, 3, 2, 1])
s.check_regular(
array([
nan, nan, nan, nan,
zsc(a[0:5]),
zsc(a[1:6]),
zsc(a[2:7])
]),
func,
(a, -15),
suffix='negative_period',
exception=YaUberAlgoArgumentError,
)
a = array([3, 2, 1, 4, 3, 2, 1])
s.check_regular(array(
[nan, nan, nan, nan,
zsc(a[0:5]),
zsc(a[1:6]),
zsc(a[2:7])]),
func, (a, 4),
suffix='period_less_5',
exception=YaUberAlgoInternalError)
a = array([nan, 2, 1, 4, 3, 2, nan, 2])
s.check_regular(array([
nan, nan, nan, nan, nan, nan, nan,
zsc(pd.Series(a).dropna().values)
]),
func, (a, 7),
suffix='numpy_with_nan')
a = array([inf, 2, 1, 4, 3, 2, nan])
s.check_naninf(array([nan, nan, nan, nan, nan, nan, nan]),
func, (a, 7),
suffix='numpy_with_nan')
a = array([3, 2, 1, 4, 3, 2, 1])
s.check_series(pd.Series(
array([
nan, nan, nan, nan,
zsc(a[0:5]),
zsc(a[1:6]),
zsc(a[2:7])
])),
func, (pd.Series(a), 5),
suffix='')
a = array([3, 2, 1, 4, 3, 2, 1], dtype=np.float)
s.check_dtype_float(array(
[nan, nan, nan, nan,
zsc(a[0:5]),
zsc(a[1:6]),
zsc(a[2:7])],
dtype=np.float),
func, (a, 5),
suffix='')
a = array([3, 2, 1, 4, 3, 2, 1], dtype=np.int32)
s.check_dtype_int(array(
[nan, nan, nan, nan,
zsc(a[0:5]),
zsc(a[1:6]),
zsc(a[2:7])],
dtype=np.float),
func, (a, 5),
suffix='')
a = array([0, 1, 1, 0, 0, 1, 1], dtype=np.bool)
s.check_dtype_bool(array(
[nan, nan, nan, nan,
zsc(a[0:5]),
zsc(a[1:6]),
zsc(a[2:7])],
dtype=np.float),
func, (a, 5),
suffix='')
a = array([0, 1, 1, 0, 0, 1, 1], dtype=np.object)
s.check_dtype_object(func, (a, 5), suffix='')
s.check_futref(
5,
1,
func,
(np.random.random(100), 5),
)
s.check_window_consistency(
5,
1,
func,
(np.random.random(100), 5),
)
def test_roc(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import roc
#
# Function settings
#
algo = 'roc'
func = roc
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(array([nan, 0, 0, 0, 0, 0, 0]),
func, (array([3, 3, 3, 3, 3, 3, 3]), 1),
suffix='no_change')
s.check_regular(array([nan, 4 / 3 - 1, 3 / 4 - 1, 0, 0, 0, 0]),
func, (array([3, 4, 3, 3, 3, 3, 3]), 1),
suffix='1period')
s.check_regular(array([nan, nan, 4 / 3 - 1, 0, 3 / 4 - 1, 0, 0]),
func, (array([3, 3, 4, 3, 3, 3, 3]), 2),
suffix='2period')
s.check_regular(array([nan, 0, 0, 0, 0, 0, 0]),
func, (array([0, 3, 3, 3, 3, 3, 3]), 1),
suffix='zeros_not_allowed',
exception=YaUberAlgoInternalError)
s.check_regular(array([nan, 0, 0, 0, 0, 0, 0]),
func, (array([3, 3, 3, 3, 3, 3, 0]), 1),
suffix='zeros_not_allowed_at_end',
exception=YaUberAlgoInternalError)
s.check_regular(array([nan, 0, 0, 0, 0, 0, 0]),
func, (array([-3, 3, 3, 3, 3, 3, 3]), 1),
suffix='negative_not_allowed',
exception=YaUberAlgoInternalError)
s.check_regular(array([nan, 0, 0, 0, 0, 0, 0]),
func, (array([3, 3, 3, 3, 3, 3, -3]), 1),
suffix='negative_not_allowed_at_end',
exception=YaUberAlgoInternalError)
s.check_regular(array([nan, 0, 0, 0, 0, 0, 0]),
func, (array([3, 3, 3, 3, 3, 3, 3]), 0),
suffix='no_zero_period',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, 0, 0, 0, 0, 0, 0]),
func, (array([3, 3, 3, 3, 3, 3, 3]), -1),
suffix='no_negative_period',
exception=YaUberAlgoArgumentError)
s.check_series(pd.Series(
array([nan, 4 / 3 - 1, 3 / 4 - 1, 0, 0, 0, 0])),
func, (pd.Series(array([3, 4, 3, 3, 3, 3, 3])), 1),
suffix='1period')
s.check_naninf(array([nan, nan, 3 / 4 - 1, 0, 0, nan, nan]),
func, (array([nan, 4, 3, 3, 3, inf, nan]), 1),
suffix='1period')
s.check_dtype_float(
array([nan, 4 / 3 - 1, 3 / 4 - 1, 0, 0, 0, 0], dtype=np.float),
func, (array([3, 4, 3, 3, 3, 3, 3], dtype=np.float), 1),
suffix='1period')
s.check_dtype_int(
array([nan, 4 / 3 - 1, 3 / 4 - 1, 0, 0, 0, 0], dtype=np.float),
func, (array([3, 4, 3, 3, 3, 3, 3], dtype=np.int32), 1),
suffix='1period')
s.check_dtype_bool(
array([nan, 0, 0, 0, 0, 0, 0], dtype=np.float),
func, (array([1, 1, 1, 1, 1, 1, 1], dtype=np.bool), 1),
suffix='1period',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_object(
func, (array([3, 4, 3, 3, 3, 3, 3], dtype=np.object), 1),
suffix='1period')
s.check_futref(
5,
1,
func,
(
# This test might fail due to YaUberInternalError - because of zero values
np.random.random(100),
5),
)
s.check_window_consistency(
5,
1,
func,
(
# This test might fail due to YaUberInternalError - because of zero values
np.random.random(100),
5),
)
def test_sum(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import sum
#
# Function settings
#
algo = 'sum'
func = sum
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3
),
suffix='regular_sum'
)
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
-1,
),
suffix='regular_neg_period',
exception=YaUberAlgoArgumentError
)
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
0,
),
suffix='regular_zero_period',
exception=YaUberAlgoArgumentError
)
s.check_regular(
array([nan, nan, nan, 6, 7, 9, 6]),
func,
(
array([3, 2, nan, 4, 3, 2, 1]),
3
),
suffix='regular_nan_skipped'
)
s.check_regular(
array([nan, nan, 2, nan, nan, nan, nan]),
func,
(
array([nan, nan, 2, nan, nan, nan, nan]),
3
),
suffix='regular_nan_filled'
)
s.check_regular(
array([nan, nan, nan, 4, 7, 9, 6]),
func,
(
array([nan, nan, nan, 4, 3, 2, 1]),
3
),
suffix='regular_nan_skipped2'
)
s.check_naninf(
array([nan, nan, nan, 4, 7, 9, 6]),
func,
(
array([nan, inf, -inf, 4, 3, 2, 1]),
3
),
suffix=''
)
s.check_naninf(
array([nan, nan, nan, 4, 7, 9, nan]),
func,
(
array([nan, inf, -inf, 4, 3, 2, nan]),
3
),
suffix='codex_20180209'
)
s.check_series(
pd.Series(array([nan, nan, 6, 7, 8, 9, 6])),
func,
(
pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
3
),
suffix='ser'
)
s.check_dtype_float(
array([nan, nan, 6, 7, 8, 9, 6], dtype=np.float),
func,
(
array([3, 2, 1, 4, 3, 2, 1], dtype=np.float),
3
),
)
s.check_dtype_bool(
array([nan, nan, 2, 2, 1, 1, 1], dtype=np.float),
func,
(
array([0, 1, 1, 0, 0, 1, 0], dtype=np.bool),
3
),
)
s.check_dtype_int(
array([nan, nan, 6, 7, 8, 9, 6], dtype=np.float),
func,
(
array([3, 2, 1, 4, 3, 2, 1], dtype=np.int32),
3
),
)
s.check_dtype_object(
func,
(
array([3, 2, 1, 4, 3, 2, 1], dtype=np.object),
3
),
)
s.check_futref(5, 1,
func,
(
np.random.random(100),
5
),
)
s.check_window_consistency(5, 1,
func,
(
np.random.random(100),
5
),
)
def test_ref(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import ref
#
# Function settings
#
algo = 'ref'
func = ref
setattr(sys.modules[func.__module__], 'IS_WARN_FUTREF', False)
setattr(sys.modules[func.__module__], 'IS_RAISE_FUTREF', False)
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([3., 4., 5., 6., 7., 8., 9., 10., nan, nan]),
func, (sc.SAMPLE_10_FLOAT, 2),
suffix='fut_ref'
)
s.check_regular(
array([3., 4., 5., 6., 7., 8., 9., 10., nan, nan]),
func, ([2, 3, 4, 5, 6], 2),
suffix='wrong_type',
exception=YaUberAlgoArgumentError,
)
s.check_regular(
pd.Series([nan, nan, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
index=[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]),
func, (np.array([True, nan], dtype=np.object), -2),
suffix='wrong_type_ndarr',
exception=YaUberAlgoDtypeNotSupportedError,
)
s.check_regular(
pd.Series([nan, nan, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
index=[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]),
func, (pd.Series([True, nan], dtype=np.object), -2),
suffix='wrong_type_series',
exception=YaUberAlgoDtypeNotSupportedError,
)
s.check_regular(
array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]),
func, (sc.SAMPLE_10_FLOAT, -20),
suffix='shift_too_low'
)
s.check_regular(
array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]),
func, (sc.SAMPLE_10_FLOAT, 20),
suffix='shift_too_high'
)
s.check_regular(
array([nan, nan, 1., 2., 3., 4., 5., 6., 7., 8.]),
func, (sc.SAMPLE_10_FLOAT, -2),
suffix='previous'
)
#
# Check typing
#
s.check_series(
pd.Series([nan, nan, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
index=[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]),
func, (sc.SAMPLE_10S_FLOAT, -2),
)
s.check_dtype_float(
array([nan, nan, 1., 2., 3., 4., 5., 6., 7., 8.]),
func, (sc.SAMPLE_10_FLOAT, -2),
)
s.check_dtype_bool(
array([nan, 1., 1., 0., 0., 1., 1., 0., 0., 1.]),
func, (sc.SAMPLE_10_BOOL, -1),
)
s.check_dtype_int(
array([nan, nan, 1., 2., 3., 4., 5., 6., 7., 8.]),
func, (sc.SAMPLE_10_INT, -2),
)
s.check_dtype_object(
func, (sc.SAMPLE_10_OBJ, -2),
)
#
# Check missing variables handling
#
s.check_naninf(
array([nan, nan, 1., 2., nan, 4., 5., 6., nan, 8.]),
func, (sc.SAMPLE_10_NANINF, -2),
ignore_nan_argument_position_check=True
)
#
# Check for future reference
#
s.check_futref(5, 1,
func, (sc.SAMPLE_10_FLOAT, -2),
min_checks_count=3,
)
setattr(sys.modules[func.__module__], 'IS_WARN_FUTREF', True)
setattr(sys.modules[func.__module__], 'IS_RAISE_FUTREF', True)
s.check_futref(3, 1,
func, (sc.SAMPLE_10_FLOAT, 2),
expected=True, # Warning: this means that we expect future reference
suffix='expected'
)
setattr(sys.modules[func.__module__], 'IS_WARN_FUTREF', False)
setattr(sys.modules[func.__module__], 'IS_RAISE_FUTREF', False)
s.check_window_consistency(4, 1,
func, (sc.SAMPLE_10_FLOAT, -3),
# expected=True, # Warning: this means that we expect future reference
# suffix='expected'
)
def test_rsi(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import rsi
#
# Function settings
#
algo = 'rsi'
func = rsi
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(array([nan, 50, 50, 50, 50, 50, 50]),
func, (array([3, 3, 3, 3, 3, 3, 3]), 1),
suffix='no_change_means50')
s.check_regular(array([nan, 50, 50, 50, 50, 50, 50]),
func, (array([3, 3, 3, 3, 3, 3, 3]), 0),
suffix='period_zero',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, 50, 50, 50, 50, 50, 50]),
func, (array([3, 3, 3, 3, 3, 3, 3]), -1),
suffix='period_negative',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, 50, 100, 0, 50, 50, 50]),
func, (array([3, 3, 4, 3, 3, 3, 3]), 1),
suffix='up_down')
s.check_regular(
# rsi = 100*avg_up_chg/(avg_up_chg + avg_dn_chg)
array([
nan, nan, nan, 100.0, 1 / (1 + 2) * 100, 1 / (1 + 2) * 100,
0 / (0 + 2) * 100
]),
func,
(array([3, 3, 4, 5, 3, 3, 3]), 3),
suffix='up_averaging')
s.check_regular(
# rsi = 100*avg_up_chg/(avg_up_chg + avg_dn_chg)
array([nan, nan, nan, 100, nan, nan, 50]),
func,
(array([3, 3, 4, 5, nan, 3, 3]), 3),
suffix='nan_skipped')
s.check_regular(
# rsi = 100*avg_up_chg/(avg_up_chg + avg_dn_chg)
array([
nan, nan, nan, 1 / (1 + 0) * 100, 1 / (1 + 2) * 100,
1 / (1 + 2) * 100, 1 / (1 + 1.5) * 100
]),
func,
(array([3, 3, 4, 5, 3, 4, 3]), 3),
suffix='dn_averaging')
s.check_regular(
# rsi = 100*avg_up_chg/(avg_up_chg + avg_dn_chg)
array([nan, nan, nan, 100, nan, nan, 50]),
func,
(array([nan, 3, 4, 5, nan, 3, 3]), 3),
suffix='nan_old_excluded')
s.check_regular(
# rsi = 100*avg_up_chg/(avg_up_chg + avg_dn_chg)
array([nan, nan, nan, 100, nan, nan, 50]),
func,
(array([nan, nan, 4, 5, nan, 3, 3]), 3),
suffix='nan_old_excluded2')
s.check_regular(
# rsi = 100*avg_up_chg/(avg_up_chg + avg_dn_chg)
array([nan, nan, nan, 0, nan, nan, 50]),
func,
(array([nan, nan, 6, 5, nan, 3, 3]), 3),
suffix='nan_old_excluded2_dn')
s.check_naninf(
# rsi = 100*avg_up_chg/(avg_up_chg + avg_dn_chg)
array([nan, nan, nan, 0, nan, nan, 50]),
func,
(array([nan, inf, 6, 5, nan, 3, 3]), 3),
suffix='nan_old_excluded2_dn')
s.check_series(pd.Series(array([nan, 50, 50, 50, 50, 50, 50])),
func, (pd.Series(array([3, 3, 3, 3, 3, 3, 3])), 1),
suffix='')
s.check_dtype_float(array([nan, 50, 100, 0, 50, 50, 50],
dtype=float),
func,
(array([3, 3, 4, 3, 3, 3, 3], dtype=float), 1),
suffix='')
s.check_dtype_int(
array([nan, 50, 100, 0, 50, 50, 50], dtype=float),
func, (array([3, 3, 4, 3, 3, 3, 3], dtype=np.int32), 1),
suffix='')
s.check_dtype_bool(
array([nan, 100, 0, 100, 50, 50, 50], dtype=float),
func, (array([0, 1, 0, 1, 1, 1, 1], dtype=np.bool), 1),
suffix='',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_object(
func,
(array([0, 1, 0, 1, 1, 1, 1], dtype=np.object), 1),
suffix='',
)
s.check_futref(
5,
1,
func,
(np.random.random(1000), 15),
)
s.check_window_consistency(
5,
1,
func,
(np.random.random(1000), 15),
)
def test_nz(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import nz
#
# Function settings
#
algo = 'nz'
func = nz
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([3, 2, 2, 4, 3, 2, 1], dtype=np.float),
func,
(
array([3, 2, 2, 4, 3, 2, 1], dtype=np.float),
0.0,
),
suffix='regular'
)
s.check_regular(
array([3, 2, 0.0, 4, 3, 2, 0.0], dtype=np.float),
func,
(
array([3, 2, nan, 4, 3, 2, inf], dtype=np.float),
0.0,
),
suffix='nan_inf'
)
s.check_regular(
array([3, 2, 0.0, 4, 3, 2, 0.0], dtype=np.float),
func,
(
array([3, 2, nan, 4, 3, 2, inf], dtype=np.float),
inf,
),
suffix='fill_by_inf',
exception=YaUberAlgoArgumentError
)
s.check_regular(
array([3, 2, 0.0, 4, 3, 2, 0.0], dtype=np.float),
func,
(
array([3, 2, nan, 4, 3, 2, inf], dtype=np.float),
inf,
),
suffix='fill_by_nan',
exception=YaUberAlgoArgumentError
)
s.check_naninf(
array([3, 2, 0.0, 4, 3, 2, 0.0], dtype=np.float),
func,
(
array([3, 2, nan, 4, 3, 2, inf], dtype=np.float),
0.0,
),
suffix='nan_inf',
ignore_nan_argument_position_check=True
)
s.check_regular(
array([3, 2, 1.0, 4, 3, 2, 1.0], dtype=np.float),
func,
(
array([3, 2, nan, 4, 3, 2, inf], dtype=np.float),
True,
),
suffix='nan_bool'
)
s.check_regular(
array([3, 2, 1.0, 4, 3, 2, 1.0], dtype=np.float),
func,
(
array([3, 2, nan, 4, 3, 2, inf], dtype=np.float),
1,
),
suffix='nan_int'
)
s.check_regular(
array([3, 2, 1.0, 4, 3, 2, 1.0], dtype=np.float),
func,
(
array([3, 2, nan, 4, 3, 2, inf], dtype=np.float),
'ok',
),
suffix='nan_object',
exception=YaUberAlgoArgumentError
)
s.check_series(
pd.Series(array([3, 2, 0.0, 4, 3, 2, 0.0], dtype=np.float)),
func,
(
pd.Series(array([3, 2, nan, 4, 3, 2, inf], dtype=np.float)),
0.0,
),
suffix='regular'
)
s.check_dtype_float(
array([3, 2, 2, 4, 3, 2, 0.0], dtype=np.float),
func,
(
array([3, 2, 2, 4, 3, 2, nan], dtype=np.float),
0.0,
),
suffix='regular'
)
s.check_dtype_bool(
array([0, 1, 0, 1, 0, 1, 0.0], dtype=np.float),
func,
(
array([0, 1, 0, 1, 0, 1, 0], dtype=np.bool),
0.0,
),
suffix='regular'
)
s.check_dtype_int(
array([0, 1, 0, 1, 0, 1, 0.0], dtype=np.float),
func,
(
array([0, 1, 0, 1, 0, 1, 0], dtype=np.int32),
0.0,
),
suffix='regular'
)
s.check_dtype_object(
func,
(
array([0, 1, 0, 1, 0, 1, 0], dtype=np.object),
0.0,
),
suffix='regular'
)
s.check_futref(5, 1,
func,
(
np.random.random(100),
0.0
),
)
s.check_window_consistency(5, 1,
func,
(
np.random.random(100),
0.0
),
)
def test_cross_up(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import cross_up
#
# Function settings
#
algo = 'cross_up'
func = cross_up
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([nan, 0, 0, 1, 0, 0, 0], dtype=np.float),
func,
(
np.array([1, 2, 2, 4, 4, 4, 4]), # arr2
np.array([1, 2, 3, 3, 4, 4, 4]), # arr_threshold
),
suffix='cond')
s.check_regular(
array([nan, 0, 0, 1, 0, 0, 0], dtype=np.float),
func,
(
np.array([1, 2, 2, 4, 4, 4, 4]), # arr2
3, # arr_threshold
),
suffix='number_threshold')
s.check_regular(
array([nan, 0, 0, 0, 0, 0, 0], dtype=np.float),
func,
(
np.array([1, 2, 3, 4, 4, 4, 4]), # arr2
np.array([1, 2, 3, 3, 4, 4, 4]), # arr_threshold
),
suffix='equal_is_ignored')
s.check_regular(
array([nan, 0, 0, 1, 0, 0, 0], dtype=np.float),
func,
(
np.array([1, 2, 2, 4, 4, 5, 2]), # arr2
np.array([1, 2, 3, 3, 4, 4, 4]), # arr_threshold
),
suffix='crossdown_is_ignored')
s.check_regular(
array([nan, 0, 0, nan, nan, 0, 0], dtype=np.float),
func,
(
np.array([1, 2, 2, 4, 4, 5, 2]), # arr2
np.array([1, 2, 3, nan, 4, 4, 4]), # arr_threshold
),
suffix='nan_threshold')
s.check_regular(
array([nan, nan, nan, nan, nan, nan, nan], dtype=np.float),
func,
(
np.array([1, 2, 2, 4, 4, 5, 2]), # arr2
nan,
),
suffix='nan_num')
s.check_regular(
array([nan, 0, 0, nan, nan, 0, 0], dtype=np.float),
func,
(
np.array([1, 2, 2, nan, 4, 5, 2]), # arr2
np.array([1, 2, 3, 3, 4, 4, 4]), # arr_threshold
),
suffix='nan_array')
s.check_naninf(
array([nan, 0, 0, nan, nan, 0, nan], dtype=np.float),
func,
(
np.array([1, 2, 2, inf, 4, 5, nan]), # arr2
np.array([1, 2, 3, 3, 4, 4, 4]), # arr_threshold
),
suffix='inf_array')
s.check_naninf(
array([nan, 0, 0, nan, nan, 0, nan], dtype=np.float),
func,
(
np.array([1, 2, 2, 3, 4, 5, 2]), # arr2
np.array([1, 2, 3, inf, 4, 4, nan]), # arr_threshold
),
suffix='inf_threshold')
s.check_series(
pd.Series(array([nan, 0, 0, 1, 0, 0, 0], dtype=np.float)),
func,
(
pd.Series(np.array([1, 2, 2, 4, 4, 4, 4])), # arr2
pd.Series(np.array([1, 2, 3, 3, 4, 4, 4
])), # arr_threshold
),
suffix='cond')
s.check_dtype_float(
array([nan, 0, 0, 1, 0, 0, 0], dtype=np.float),
func,
(
np.array([1, 2, 2, 4, 4, 4, 4], dtype=np.float), # arr2
np.array([1, 2, 3, 3, 4, 4, 4],
dtype=np.float), # arr_threshold
),
suffix='cond')
s.check_dtype_int(
array([nan, 0, 0, 1, 0, 0, 0], dtype=np.float),
func,
(
np.array([1, 2, 2, 4, 4, 4, 4], dtype=np.int32), # arr2
np.array([1, 2, 3, 3, 4, 4, 4],
dtype=np.int32), # arr_threshold
),
suffix='cond')
s.check_dtype_bool(
array([nan, 0, 0, 0, 0, 0, 0], dtype=np.float),
func,
(
np.array([1, 1, 1, 0, 1, 1, 0], dtype=np.bool), # arr2
np.array([1, 0, 1, 0, 1, 0, 1],
dtype=np.bool), # arr_threshold
),
suffix='cond')
s.check_dtype_object(
func,
(
np.array([1, 1, 1, 0, 1, 1, 0], dtype=np.object), # arr2
np.array([1, 0, 1, 0, 1, 0, 1],
dtype=np.object), # arr_threshold
),
suffix='cond')
s.check_futref(
5,
1,
func,
(
np.array([1, 2, 2, 4, 4, 4, 4, 5, 7, 8]), # arr2
np.array([1, 2, 3, 3, 4, 4, 4, 2, 5, 6]), # arr_threshold
),
suffix='cond',
min_checks_count=3,
)
s.check_window_consistency(
5,
1,
func,
(
np.array([1, 2, 2, 4, 4, 4, 4, 5, 7, 8]), # arr2
np.array([1, 2, 3, 3, 4, 4, 4, 2, 5, 6]), # arr_threshold
),
suffix='cond',
min_checks_count=3,
)
def test_bars_since(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import bars_since
#
# Function settings
#
algo = 'bars_since'
func = bars_since
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([nan, nan, 0, 1, 0, 0], dtype=np.float),
func,
(
array([0, 0, 1, 0, 1, 1], dtype=np.float), # cond
),
suffix='cond')
s.check_regular(
array([nan, nan, 0, 1, nan, 0], dtype=np.float),
func,
(
array([0, 0, 1, 0, nan, 1], dtype=np.float), # cond
),
suffix='cond_nan')
s.check_regular(
array([nan, nan, nan, nan, nan, nan], dtype=np.float),
func,
(
array([0, 0, 0, 0, nan, nan], dtype=np.float), # cond
),
suffix='cond_nan2')
s.check_naninf(
array([nan, nan, nan, nan, nan, nan], dtype=np.float),
func,
(
array([0, 0, 0, inf, nan, nan], dtype=np.float), # cond
),
suffix='codex20180209')
s.check_regular(
array([nan, nan, nan, nan, nan, nan], dtype=np.float),
func,
(
array([0, inf, 2, 0, nan, nan], dtype=np.float), # cond
),
suffix='cond_non_binary_raises',
exception=YaUberAlgoInternalError,
)
s.check_series(
pd.Series(array([nan, nan, 0, 1, 0, 0], dtype=np.float)),
func,
(
pd.Series(array([0, 0, 1, 0, 1, 1],
dtype=np.float)), # cond
),
suffix='cond')
s.check_dtype_float(
array([nan, nan, 0, 1, 0, 0], dtype=np.float),
func,
(
array([0, 0, 1, 0, 1, 1], dtype=np.float), # cond
),
suffix='cond')
s.check_dtype_bool(
array([nan, nan, 0, 1, 0, 0], dtype=np.float),
func,
(
array([0, 0, 1, 0, 1, 1], dtype=np.bool), # cond
),
suffix='cond')
s.check_dtype_int(
array([nan, nan, 0, 1, 0, 0], dtype=np.float),
func,
(
array([0, 0, 1, 0, 1, 1], dtype=np.int32), # cond
),
suffix='cond')
s.check_dtype_object(
func,
(
array([0, 0, 1, 0, 1, 1], dtype=np.object), # cond
),
suffix='cond')
s.check_futref(
5,
1,
func,
(
array([0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
dtype=np.float), # cond
),
min_checks_count=3,
)
s.check_window_consistency(
5,
1,
func,
(
array([0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
dtype=np.float), # cond
),
min_checks_count=3,
)
def test_quantile(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import quantile
#
# Function settings
#
algo = 'quantile'
func = quantile
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(array([nan, nan, nan, nan, 3, 4, 5]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5, 0.5),
suffix='reg')
s.check_regular(array([nan, nan, nan, nan, 3, 4, 7]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5,
array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 1])),
suffix='quantile_arr')
s.check_regular(array([nan, nan, nan, nan, 3, 4, nan]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5,
array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, nan])),
suffix='quantile_arr_nan')
s.check_regular(array([nan, nan, nan, nan, 3, 4, nan]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5,
array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, inf])),
suffix='quantile_arr_inf',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, nan, nan, nan, 3, 4, nan]),
func,
(array([1, 2, 3, 4, 5, 6, 7]), 5,
array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 1.00001])),
suffix='quantile_q_out_of_bounds_up',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, nan, nan, nan, 3, 4, nan]),
func,
(array([1, 2, 3, 4, 5, 6, 7]), 5,
array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.000001])),
suffix='quantile_q_out_of_bounds_dn',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, nan, nan, nan, nan, nan, nan]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5, nan),
suffix='reg_quantile_nan')
s.check_regular(array([nan, nan, nan, nan, nan, 3.5, 4.5]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 6, 0.5),
suffix='midpoint')
s.check_regular(array([nan, nan, nan, nan, 3, 4, 5]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 4, 0.5),
suffix='min_period_error',
exception=YaUberAlgoInternalError)
s.check_regular(array([nan, nan, nan, nan, nan, 4, 5]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5, -0.00001),
suffix='q_bounds_check_lower',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, nan, nan, nan, nan, 4, 5]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5, 1.00001),
suffix='q_bounds_check_upper',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, nan, nan, nan, nan, 4, 5]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 0, 0.5),
suffix='negative_per',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, nan, nan, nan, 5, 6, 7]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5, 1.0),
suffix='q_top')
s.check_regular(array([nan, nan, nan, nan, 1, 2, 3]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5, 0.0),
suffix='q_bot')
s.check_regular(array([nan, nan, nan, nan, 4.5, 5.5, 6.5]),
func, (array([1, 2, 3, 4, 5, 6, 7]), 5, 0.95),
suffix='q_95_midpoint')
s.check_regular(array([nan, nan, nan, nan, nan, nan, 4, 5, 6, 7]),
func,
(array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 7, 0.5),
suffix='reg10')
s.check_regular(
array([nan, nan, nan, nan, nan, nan, 5, 5.5, 6, 7]),
func, (array([nan, nan, 3, 4, 5, 6, 7, 8, 9, 10]), 7, 0.5),
suffix='skip_nan_in_quantile_calcs')
s.check_naninf(
array([nan, nan, nan, nan, nan, nan, 4.5, 5, 6, nan]),
func, (array([inf, 2, 3, 4, 5, 6, 7, 8, 9, nan]), 7, 0.5),
suffix='nan_last')
s.check_dtype_float(
array([nan, nan, nan, nan, 3, 4, 5], dtype=np.float),
func, (array([1, 2, 3, 4, 5, 6, 7], dtype=np.float), 5, 0.5),
suffix='')
s.check_dtype_int(
array([nan, nan, nan, nan, 3, 4, 5], dtype=np.float),
func, (array([1, 2, 3, 4, 5, 6, 7], dtype=np.int32), 5, 0.5),
suffix='')
s.check_dtype_bool(
array([nan, nan, nan, nan, 1, 0, 1], dtype=np.float),
func, (array([1, 0, 1, 0, 1, 0, 1], dtype=np.bool), 5, 0.5),
suffix='',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_bool(
array([nan, nan, nan, nan, nan, .5, .5], dtype=np.float),
func, (array([1, 0, 1, 0, 1, 0, 1], dtype=np.bool), 6, 0.5),
suffix='midpoint',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_object(
func, (array([1, 2, 3, 4, 5, 6, 7], dtype=np.object), 5, 0.5),
suffix='')
s.check_series(pd.Series(array([nan, nan, nan, nan, 3, 4, 5])),
func,
(pd.Series(array([1, 2, 3, 4, 5, 6, 7])), 5, 0.5),
suffix='reg')
s.check_futref(
5,
1,
func,
(np.random.random(1000), 50, 0.5),
)
s.check_window_consistency(
5,
1,
func,
(np.random.random(1000), 50, 0.5),
)
def test_rsi(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import updn_ratio
#
# Function settings
#
algo = 'updn_ratio'
func = updn_ratio
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(array([nan, .50, .50, .50, .50, .50, .50]),
func, (array([3, 3, 3, 3, 3, 3, 3]), 1),
suffix='no_change_means50')
s.check_regular(array([nan, .50, .50, .50, .50, .50, .50]),
func, (array([3, 3, 3, 3, 3, 3, 3]), 0),
suffix='period_zero',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, .50, .50, .50, .50, .50, .50]),
func, (array([3, 3, 3, 3, 3, 3, 3]), -1),
suffix='period_negative',
exception=YaUberAlgoArgumentError)
s.check_regular(array([nan, .50, 1.00, 0, .50, .50, .50]),
func, (array([3, 3, 4, 3, 3, 3, 3]), 1),
suffix='up_down')
s.check_regular(
# result[i] = ((upcnt+dncnt*-1) / (dncnt + upcnt + medcnt) + 1) / 2.0
array([
nan, nan, nan, ((2 + 0 * -1) / 3 + 1) / 2.0,
((2 + 1 * -1) / 3 + 1) / 2.0, ((1 + 1 * -1) / 3 + 1) / 2.0,
((0 + 1 * -1) / 3 + 1) / 2.0
]),
func,
(array([3, 3, 4, 5, 3, 3, 3]), 3),
suffix='up_averaging')
s.check_regular(array([nan, nan, nan, 0.83333333, nan, nan, .50]),
func, (array([3, 3, 4, 5, nan, 3, 3]), 3),
suffix='nan_skipped')
s.check_regular(array([nan, nan, nan, 1.00, nan, nan, .50]),
func, (array([nan, 3, 4, 5, nan, 3, 3]), 3),
suffix='nan_old_excluded')
s.check_regular(array([nan, nan, nan, 1.00, nan, nan, .50]),
func, (array([nan, nan, 4, 5, nan, 3, 3]), 3),
suffix='nan_old_excluded2')
s.check_regular(array([nan, nan, nan, 0, nan, nan, .50]),
func, (array([nan, nan, 6, 5, nan, 3, 3]), 3),
suffix='nan_old_excluded2_dn')
s.check_naninf(array([nan, nan, nan, 0, nan, nan, .50]),
func, (array([nan, inf, 6, 5, nan, 3, 3]), 3),
suffix='nan_old_excluded2_dn')
s.check_series(pd.Series(array([nan, .50, .50, .50, .50, .50,
.50])),
func, (pd.Series(array([3, 3, 3, 3, 3, 3, 3])), 1),
suffix='')
s.check_dtype_float(array([nan, .50, 1.00, 0, .50, .50, .50],
dtype=float),
func,
(array([3, 3, 4, 3, 3, 3, 3], dtype=float), 1),
suffix='')
s.check_dtype_int(
array([nan, .50, 1.00, 0, .50, .50, .50], dtype=float),
func, (array([3, 3, 4, 3, 3, 3, 3], dtype=np.int32), 1),
suffix='')
s.check_dtype_bool(
array([nan, .50, 1.00, 0, .50, .50, .50], dtype=float),
func, (array([0, 1, 0, 1, 1, 1, 1], dtype=np.bool), 1),
suffix='',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_object(
func,
(array([0, 1, 0, 1, 1, 1, 1], dtype=np.object), 1),
suffix='',
)
s.check_futref(
5,
1,
func,
(np.random.random(1000), 15),
)
s.check_window_consistency(
5,
1,
func,
(np.random.random(1000), 15),
)
def test_max(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import max
#
# Function settings
#
algo = 'max'
func = max
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(array([3, 2, 2, 4, 3, 2, 1], dtype=np.float),
func, (
array([3, 2, 1, 4, 3, 0, 1], dtype=np.float),
array([3, 2, 2, 1, 1, 2, 1], dtype=np.float),
),
suffix='regular')
s.check_regular(array([3, 2, 2, 4, 3, 2, 1], dtype=np.float),
func, (
array([3, 2, 2, 1, 1, 2, 1], dtype=np.float),
array([3, 2, 1, 4, 3, 0, 1], dtype=np.float),
),
suffix='regular_reverse')
s.check_naninf(
array([nan, 2, nan, 4, 3, 2, nan], dtype=np.float),
func, (
array([inf, 2, nan, 1, 1, 2, nan], dtype=np.float),
array([3, 2, 1, 4, 3, 0, 1], dtype=np.float),
),
suffix='nan_inf_arr1')
s.check_naninf(
array([nan, 2, nan, 4, 3, 2, nan], dtype=np.float),
func, (
array([3, 2, 1, 4, 3, 0, 1], dtype=np.float),
array([inf, 2, nan, 1, 1, 2, nan], dtype=np.float),
),
suffix='nan_inf_arr2')
s.check_series(
pd.Series(array([3, 2, 2, 4, 3, 2, 1], dtype=np.float)),
func, (
pd.Series(array([3, 2, 1, 4, 3, 0, 1], dtype=np.float)),
pd.Series(array([3, 2, 2, 1, 1, 2, 1], dtype=np.float)),
),
suffix='')
s.check_dtype_float(
array([3, 2, 2, 4, 3, 2, 1], dtype=np.float),
func, (
array([3, 2, 1, 4, 3, 0, 1], dtype=np.float),
array([3, 2, 2, 1, 1, 2, 1], dtype=np.float),
),
suffix='regular')
s.check_dtype_int(array([3, 2, 2, 4, 3, 2, 1], dtype=np.float),
func, (
array([3, 2, 1, 4, 3, 0, 1], dtype=np.int32),
array([3, 2, 2, 1, 1, 2, 1], dtype=np.int32),
),
suffix='regular')
s.check_dtype_bool(array([0, 1, 1, 1, 0, 1, 1], dtype=np.float),
func, (
array([0, 0, 1, 0, 0, 0, 1], dtype=np.bool),
array([0, 1, 0, 1, 0, 1, 1], dtype=np.bool),
),
suffix='regular')
s.check_dtype_object(func, (
array([0, 0, 1, 0, 0, 0, 1], dtype=np.object),
array([0, 1, 0, 1, 0, 1, 1], dtype=np.object),
),
suffix='regular')
s.check_futref(
5,
1,
func,
(
np.random.random(100),
np.random.random(100),
),
)
s.check_window_consistency(
5,
1,
func,
(
np.random.random(100),
np.random.random(100),
),
)
def test_Sum_since(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import sum_since
#
# Function settings
#
algo = 'sum_since'
func = sum_since
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([nan, 2, 5, 4, 9, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
False, # first_is_zero
),
suffix='cond_increasing')
s.check_regular(
array([nan, 2, 5, nan, 5, 6], dtype=np.float),
func,
(
array([1, 2, 3, nan, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
False,
),
suffix='arr_nan_at_arr')
s.check_regular(
array([nan, 2, 5, nan, 10, 6], dtype=np.float),
func,
(
array([1, 2, 3, 3, 5, 6], dtype=np.float), # arr
array([0, 1, 0, nan, 0, 1], dtype=np.float), # cond
False,
),
suffix='arr_nan_at_cond')
s.check_regular(
array([nan, 0, 3, 0, 5, 0], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
True, # first_is_zero
),
suffix='first_is_zero')
s.check_regular(
array([nan, 0, 3, 0, 5, 0], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 2, 1], dtype=np.float), # cond
True, # first_is_zero
),
suffix='wrong_condition',
exception=YaUberAlgoInternalError,
)
s.check_naninf(
array([nan, 2, nan, 4, 9, nan], dtype=np.float),
func,
(
array([inf, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, nan, 1, 0, nan], dtype=np.float), # cond
False, # first_is_zero
),
suffix='cond_is_nan_codex20180209')
s.check_naninf(
array([nan, 2, nan, 4, 9, nan], dtype=np.float),
func,
(
array([inf, 2, nan, 4, 5, inf], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
False, # first_is_zero
),
suffix='arr_is_nan_codex20180209')
s.check_series(
pd.Series(array([nan, 2, 5, 4, 9, 6], dtype=np.float)),
func,
(
pd.Series(array([1, 2, 3, 4, 5, 6],
dtype=np.float)), # arr
pd.Series(array([0, 1, 0, 1, 0, 1],
dtype=np.float)), # cond
False, # first_is_zero
),
suffix='')
s.check_dtype_float(
array([nan, 2, 5, 4, 9, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.float), # cond
False, # first_is_zero
),
suffix='cond_increasing')
s.check_dtype_int(
array([nan, 2, 5, 4, 9, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.int32), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.int32), # cond
False, # first_is_zero
),
suffix='cond_increasing')
s.check_dtype_bool(
array([nan, 2, 5, 4, 9, 6], dtype=np.float),
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.float), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.bool), # cond
False, # first_is_zero
),
suffix='cond_increasing')
s.check_dtype_object(
func,
(
array([1, 2, 3, 4, 5, 6], dtype=np.object), # arr
array([0, 1, 0, 1, 0, 1], dtype=np.bool), # cond
False, # first_is_zero
),
suffix='cond_increasing')
s.check_futref(
5,
1,
func,
(np.random.random(100), np.random.random_integers(0, 1,
100), 5),
)
s.check_window_consistency(
5,
1,
func,
(np.random.random(100), np.random.random_integers(0, 1,
100), 5),
)
def test_wma(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import wma
#
# Function settings
#
algo = 'wma'
func = wma
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(array([nan, nan, 6, 7, 8, 9, 6]) / 3.0,
func, (array([3, 2, 1, 4, 3, 2, 1
]), array([1, 1, 1, 1, 1, 1, 1]), 3),
suffix='wma_equal_weight')
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]) / 3.0,
func,
(array([3, 2, 1, 4, 3, 2, 1]), array([1, 1, 1, 1, 1, 1, 1
]), 0),
suffix='period_zero',
exception=YaUberAlgoArgumentError,
)
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]) / 3.0,
func,
(array([3, 2, 1, 4, 3, 2, 1]), array([1, 1, 1, 1, 1, 1, 1
]), -1),
suffix='period_negative',
exception=YaUberAlgoArgumentError,
)
s.check_regular(array([nan, nan, 6, 7, 8, 9, 6]) / 3.0,
func,
(array([3, 2, 1, 4, 3, 2, 1
]), array([-1, 1, 1, 1, 1, 1, 1]), 3),
suffix='negative_weight',
exception=YaUberAlgoInternalError)
s.check_regular(array([nan, nan, 6, 7, 8, 9, 6]) / 3.0,
func,
(array([3, 2, 1, 4, 3, 2, 1
]), array([1, 1, 1, 1, 1, 1, -1]), 3),
suffix='negative_weight2',
exception=YaUberAlgoInternalError)
s.check_regular(array([nan, nan, nan, nan, nan, nan, nan]),
func, (array([3, 2, 1, 4, 3, 2, 1
]), array([0, 0, 0, 0, 0, 0, 0]), 3),
suffix='zero_weight')
s.check_regular(array([
nan, nan, (3 * 1 + 2 * 2 + 1 * 3) / 6,
(2 * 2 + 1 * 3 + 4 * 1) / 6, (1 * 3 + 4 + 3) / 5,
(4 * 1 + 3 * 1 + 2 * 1) / 3, (3 * 1 + 2 * 1 + 1 * 1) / 3
]),
func, (array([3, 2, 1, 4, 3, 2, 1
]), array([1, 2, 3, 1, 1, 1, 1]), 3),
suffix='wma_weight_applied')
s.check_naninf(array([nan, nan, 6, 7, 8, nan, nan]) / 3.0,
func, (array([3, 2, 1, 4, 3, inf, nan
]), array([1, 1, 1, 1, 1, 1, 1]), 3),
suffix='wma_arr_nan')
s.check_naninf(array([nan, nan, 6, 7, 8, nan, nan]) / 3.0,
func,
(array([3, 2, 1, 4, 3, 2, 1
]), array([1, 1, 1, 1, 1, nan, inf]), 3),
suffix='wma_weight_nan')
s.check_series(pd.Series(array([nan, nan, 6, 7, 8, 9, 6]) / 3.0),
func, (pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
pd.Series(array([1, 1, 1, 1, 1, 1, 1])), 3),
suffix='')
s.check_dtype_float(
array([nan, nan, 6, 7, 8, 9, 6], dtype=float) / 3.0,
func, (array([3, 2, 1, 4, 3, 2, 1], dtype=float),
array([1, 1, 1, 1, 1, 1, 1], dtype=float), 3),
suffix='')
s.check_dtype_int(
array([nan, nan, 6, 7, 8, 9, 6], dtype=float) / 3.0,
func, (array([3, 2, 1, 4, 3, 2, 1], dtype=np.int32),
array([1, 1, 1, 1, 1, 1, 1], dtype=np.int32), 3),
suffix='')
s.check_dtype_bool(
array([nan, nan, 6, 7, 8, 9, 6], dtype=float) / 3.0,
func, (array([3, 2, 1, 4, 3, 2, 1], dtype=float),
array([1, 1, 1, 1, 1, 1, 1], dtype=bool), 3),
suffix='')
s.check_dtype_object(
func, (array([3, 2, 1, 4, 3, 2, 1], dtype=np.object),
array([1, 1, 1, 1, 1, 1, 1], dtype=bool), 3),
suffix='')
s.check_futref(
5,
1,
func,
(np.random.random(100), np.random.random(100), 5),
)
s.check_window_consistency(
5,
1,
func,
(np.random.random(100), np.random.random(100), 5),
)
def test_rangehilo(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import rangehilo
import yauber_algo.algo as a
#
# Function settings
#
algo = 'rangehilo'
func = rangehilo
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
# Check with manual formula
h = l = c = o = np.random.random(1000)
rhilo = ((a.hhv(h, 20) - a.max(a.ref(o, -20 + 1), c)) +
(a.min(a.ref(o, -20 + 1), c) - a.llv(l, 20))) / (
a.hhv(h, 20) - a.llv(l, 20))
s.check_regular(rhilo, func, (o, h, l, c, 20), suffix='formula')
s.check_regular(
array([0.4]),
func,
(
array([2]), # o
array([10]), # h
array([0]), # l
array([8]), # c
1),
suffix='uptrend')
s.check_regular(
array([0.4]),
func,
(
array([2]), # o
array([10]), # h
array([0]), # l
array([18]), # c
1),
suffix='close_gt_hi',
exception=YaUberAlgoInternalError)
s.check_regular(
array([0.4]),
func,
(
array([2]), # o
array([10]), # h
array([0]), # l
array([-1]), # c
1),
suffix='close_lt_lo',
exception=YaUberAlgoInternalError)
s.check_regular(
array([0.4]),
func,
(
array([12]), # o
array([10]), # h
array([0]), # l
array([9]), # c
1),
suffix='open_gt_hi',
exception=YaUberAlgoInternalError)
s.check_regular(
array([0.4]),
func,
(
array([-2]), # o
array([10]), # h
array([0]), # l
array([1]), # c
1),
suffix='open_lt_lo',
exception=YaUberAlgoInternalError)
s.check_regular(
array([0.4]),
func,
(
array([2]), # o
array([10]), # h
array([0]), # l
array([8]), # c
0),
suffix='period_zero',
exception=YaUberAlgoArgumentError)
s.check_regular(
array([0.4]),
func,
(
array([2]), # o
array([10]), # h
array([0]), # l
array([8]), # c
-1),
suffix='period_negative',
exception=YaUberAlgoArgumentError)
s.check_regular(
array([0.4]),
func,
(
array([8]), # o
array([10]), # h
array([0]), # l
array([2]), # c
1),
suffix='dn_trend')
s.check_regular(
array([0.4]),
func,
(
array([8]), # o
array([0]), # h
array([10]), # l
array([2]), # c
1),
suffix='sanity_h_less_l',
exception=YaUberAlgoInternalError)
s.check_regular(
array([1.0]),
func,
(
array([5]), # o
array([10]), # h
array([0]), # l
array([5]), # c
1),
suffix='doji')
s.check_regular(
array([0.0]),
func,
(
array([0]), # o
array([10]), # h
array([0]), # l
array([10]), # c
1),
suffix='ideal_trend_up')
s.check_regular(
array([0.0]),
func,
(
array([10]), # o
array([10]), # h
array([0]), # l
array([0]), # c
1),
suffix='ideal_trend_dn')
s.check_regular(
array(
[0.5]
), # Fix: 2018-02-17 in this case the results must be ambiguous
func,
(
array([10]), # o
array([10]), # h
array([10]), # l
array([10]), # c
1),
suffix='flat_candle')
s.check_regular(
array([nan]),
func,
(
array([nan]), # o
array([10]), # h
array([10]), # l
array([10]), # c
1),
suffix='nan_o')
s.check_regular(
array([nan]),
func,
(
array([10]), # o
array([nan]), # h
array([10]), # l
array([10]), # c
1),
suffix='nan_h')
s.check_regular(
array([nan]),
func,
(
array([10]), # o
array([10]), # h
array([nan]), # l
array([10]), # c
1),
suffix='nan_l')
s.check_regular(
array([nan]),
func,
(
array([10]), # o
array([10]), # h
array([10]), # l
array([nan]), # c
1),
suffix='nan_c')
s.check_regular(
array([nan, 1]),
func,
(
array([5, 7]), # o
array([6, 10]), # h
array([0, 3]), # l
array([0, 5]), # c
2),
suffix='period2')
s.check_regular(
array([nan, 0.0]),
func,
(
array([0, 7]), # o
array([10, 10]), # h
array([0, 3]), # l
array([0, 10]), # c
2),
suffix='period2_alt')
s.check_regular(
array([nan, 0.0, 1.0]),
func,
(
array([0, 7, 20]), # o
array([10, 10, 20]), # h
array([0, 3, 0]), # l
array([0, 10, 7]), # c
2),
suffix='period2_alt_n3')
s.check_regular(
array([nan, nan, 1.0]),
func,
(
array([0, 7, 20]), # o
array([10, 10, 20]), # h
array([0, nan, 0]), # l
array([0, 10, 7]), # c
2),
suffix='period2_alt_n3_llv_nan')
s.check_regular(
array([nan, 0.0, 0.7]),
func,
(
array([0, 5, 2]), # o
array([10, 10, 2]), # h
array([0, 3, 0]), # l
array([0, 10, 2]), # c
2),
suffix='period2_alt_n3_hhv')
s.check_regular(
array([nan, nan, 1.0]),
func,
(
array([0, 7, 10]), # o
array([10, nan, 10]), # h
array([0, 3, 0]), # l
array([0, 10, 7]), # c
2),
suffix='period2_alt_n3_hhv_with_nan')
s.check_regular(
array([nan, nan]),
func,
(
array([nan, 7]), # o
array([6, 10]), # h
array([0, 3]), # l
array([0, 5]), # c
2),
suffix='period2_nan_open')
s.check_naninf(
array([nan, 1.0]),
func,
(
array(
[5, nan]
), # o <- ALGOCODEX exception! This is OK, because we need 1st element of open price
array([nan, 10]), # h
array([inf, 3]), # l
array([nan, 5]), # c
2),
suffix='period2_nan_ignored',
ignore_nan_argument_position_check=True,
)
s.check_series(
pd.Series(array([nan, 1])),
func,
(
pd.Series(array([5, 7])), # o
pd.Series(array([6, 10])), # h
pd.Series(array([0, 3])), # l
pd.Series(array([0, 5])), # c
2),
suffix='series')
s.check_dtype_float(
array([0.4], dtype=np.float),
func,
(
array([2], dtype=np.float), # o
array([10], dtype=np.float), # h
array([0], dtype=np.float), # l
array([8], dtype=np.float), # c
1),
)
s.check_dtype_int(
array([0.4], dtype=np.float),
func,
(
array([2], dtype=np.int32), # o
array([10], dtype=np.int32), # h
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
1),
)
s.check_dtype_bool(
array([0.4], dtype=np.float),
func,
(
array([2], dtype=np.bool), # o
array([10], dtype=np.int32), # h
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
1),
suffix='bool_o',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_bool(
array([0.4], dtype=np.float),
func,
(
array([10], dtype=np.int32), # h
array([2], dtype=np.bool), # o
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
1),
suffix='bool_h',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_bool(
array([0.4], dtype=np.float),
func,
(
array([10], dtype=np.int32), # h
array([0], dtype=np.int32), # l
array([2], dtype=np.bool), # o
array([8], dtype=np.int32), # c
1),
suffix='bool_l',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_bool(
array([0.4], dtype=np.float),
func,
(
array([10], dtype=np.int32), # h
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
array([2], dtype=np.bool), # o
1),
suffix='bool_c',
exception=YaUberAlgoDtypeNotSupportedError)
s.check_dtype_object(
func,
(
array([2], dtype=np.object), # o
array([10], dtype=np.int32), # h
array([0], dtype=np.int32), # l
array([8], dtype=np.int32), # c
1),
suffix='bool_o',
)
s.check_futref(
5,
1,
func,
(
np.random.random_integers(31, 59, 100), # o
np.random.random_integers(60, 100, 100), # h
np.random.random_integers(0, 30, 100), # l
np.random.random_integers(31, 59, 100), # c
5),
)
s.check_window_consistency(
5,
1,
func,
(
np.random.random_integers(31, 59, 100), # o
np.random.random_integers(60, 100, 100), # h
np.random.random_integers(0, 30, 100), # l
np.random.random_integers(31, 59, 100), # c
5),
)
