From 25cae024f994249fb31b08c97b4fe2543e9f8470 Mon Sep 17 00:00:00 2001 From: Kevin Johnson Date: Tue, 13 Oct 2020 10:12:10 -0700 Subject: [PATCH] STY fix weird formatting DOC rsi length default fix --- pandas_ta/momentum/rsi.py | 8 +- tests/config.py | 4 +- tests/context.py | 3 +- tests/test_ext_indicator_candle.py | 10 +-- tests/test_ext_indicator_momentum.py | 58 ++++----------- tests/test_ext_indicator_overlap_ext.py | 20 ++--- tests/test_ext_indicator_performance.py | 30 ++------ tests/test_ext_indicator_statistics.py | 7 +- tests/test_ext_indicator_trend.py | 26 ++----- tests/test_ext_indicator_volatility.py | 24 ++---- tests/test_ext_indicator_volume.py | 7 +- tests/test_indicator_candle.py | 21 +----- tests/test_indicator_momentum.py | 93 ++++++------------------ tests/test_indicator_overlap.py | 68 ++++------------- tests/test_indicator_performance.py | 32 ++------ tests/test_indicator_statistics.py | 16 +--- tests/test_indicator_trend.py | 37 ++-------- tests/test_indicator_volatility.py | 56 +++----------- tests/test_indicator_volume.py | 27 ++----- tests/test_strategy.py | 97 ++++++------------------- tests/test_utils.py | 66 +++++------------ 21 files changed, 171 insertions(+), 539 deletions(-) diff --git a/pandas_ta/momentum/rsi.py b/pandas_ta/momentum/rsi.py index 2e78594..2a18b4f 100644 --- a/pandas_ta/momentum/rsi.py +++ b/pandas_ta/momentum/rsi.py @@ -89,10 +89,10 @@ Calculation: Args: close (pd.Series): Series of 'close's - length (int): It's period. Default: 1 - scalar (float): How much to magnify. Default: 100 - drift (int): The difference period. Default: 1 - offset (int): How many periods to offset the result. Default: 0 + length (int): It's period. Default: 14 + scalar (float): How much to magnify. Default: 100 + drift (int): The difference period. Default: 1 + offset (int): How many periods to offset the result. Default: 0 Kwargs: fillna (value, optional): pd.DataFrame.fillna(value) diff --git a/tests/config.py b/tests/config.py index e9d373e..701e761 100644 --- a/tests/config.py +++ b/tests/config.py @@ -16,9 +16,7 @@ sample_data = read_csv( infer_datetime_format=True, keep_date_col=True, ) -sample_data.set_index(DatetimeIndex(sample_data["date"]), - inplace=True, - drop=True) +sample_data.set_index(DatetimeIndex(sample_data["date"]), inplace=True, drop=True) sample_data.drop("date", axis=1, inplace=True) diff --git a/tests/context.py b/tests/context.py index 66ef8ea..971b0b4 100644 --- a/tests/context.py +++ b/tests/context.py @@ -1,7 +1,6 @@ import os import sys -sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), - ".."))) +sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) import pandas_ta diff --git a/tests/test_ext_indicator_candle.py b/tests/test_ext_indicator_candle.py index bd8d621..d82991c 100644 --- a/tests/test_ext_indicator_candle.py +++ b/tests/test_ext_indicator_candle.py @@ -6,7 +6,6 @@ from pandas import DataFrame class TestCandleExtension(TestCase): - @classmethod def setUpClass(cls): cls.data = sample_data @@ -15,11 +14,9 @@ class TestCandleExtension(TestCase): def tearDownClass(cls): del cls.data - def setUp(self): - pass + def setUp(self): pass + def tearDown(self): pass - def tearDown(self): - pass def test_cdl_doji_ext(self): self.data.ta.cdl_doji(append=True) @@ -34,5 +31,4 @@ class TestCandleExtension(TestCase): def test_ha_ext(self): self.data.ta.ha(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-4:]), - ["HA_open", "HA_high", "HA_low", "HA_close"]) + self.assertEqual(list(self.data.columns[-4:]), ["HA_open", "HA_high", "HA_low", "HA_close"]) diff --git a/tests/test_ext_indicator_momentum.py b/tests/test_ext_indicator_momentum.py index c052fd2..3abb57d 100644 --- a/tests/test_ext_indicator_momentum.py +++ b/tests/test_ext_indicator_momentum.py @@ -6,7 +6,6 @@ from pandas import DataFrame class TestMomentumExtension(TestCase): - @classmethod def setUpClass(cls): cls.data = sample_data @@ -15,11 +14,9 @@ class TestMomentumExtension(TestCase): def tearDownClass(cls): del cls.data - def setUp(self): - pass + def setUp(self): pass + def tearDown(self): pass - def tearDown(self): - pass def test_ao_ext(self): self.data.ta.ao(append=True) @@ -84,8 +81,7 @@ class TestMomentumExtension(TestCase): def test_fisher_ext(self): self.data.ta.fisher(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-2:]), - ["FISHERT_9_1", "FISHERTs_9_1"]) + self.assertEqual(list(self.data.columns[-2:]), ["FISHERT_9_1", "FISHERTs_9_1"]) def test_inertia_ext(self): self.data.ta.inertia(append=True) @@ -105,22 +101,17 @@ class TestMomentumExtension(TestCase): def test_kdj_ext(self): self.data.ta.kdj(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["K_9_3", "D_9_3", "J_9_3"]) + self.assertEqual(list(self.data.columns[-3:]), ["K_9_3", "D_9_3", "J_9_3"]) def test_kst_ext(self): self.data.ta.kst(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-2:]), - ["KST_10_15_20_30_10_10_10_15", "KSTs_9"]) + self.assertEqual(list(self.data.columns[-2:]), ["KST_10_15_20_30_10_10_10_15", "KSTs_9"]) def test_macd_ext(self): self.data.ta.macd(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual( - list(self.data.columns[-3:]), - ["MACD_12_26_9", "MACDh_12_26_9", "MACDs_12_26_9"], - ) + self.assertEqual(list(self.data.columns[-3:]), ["MACD_12_26_9", "MACDh_12_26_9", "MACDs_12_26_9"]) def test_mom_ext(self): self.data.ta.mom(append=True) @@ -135,10 +126,7 @@ class TestMomentumExtension(TestCase): def test_ppo_ext(self): self.data.ta.ppo(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual( - list(self.data.columns[-3:]), - ["PPO_12_26_9", "PPOh_12_26_9", "PPOs_12_26_9"], - ) + self.assertEqual(list(self.data.columns[-3:]), ["PPO_12_26_9", "PPOh_12_26_9", "PPOs_12_26_9"]) def test_psl_ext(self): self.data.ta.psl(append=True) @@ -148,10 +136,7 @@ class TestMomentumExtension(TestCase): def test_pvo_ext(self): self.data.ta.pvo(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual( - list(self.data.columns[-3:]), - ["PVO_12_26_9", "PVOh_12_26_9", "PVOs_12_26_9"], - ) + self.assertEqual(list(self.data.columns[-3:]), ["PVO_12_26_9", "PVOh_12_26_9", "PVOs_12_26_9"]) def test_roc_ext(self): self.data.ta.roc(append=True) @@ -166,8 +151,7 @@ class TestMomentumExtension(TestCase): def test_rvgi_ext(self): self.data.ta.rvgi(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-2:]), - ["RVGI_14_4", "RVGIs_14_4"]) + self.assertEqual(list(self.data.columns[-2:]), ["RVGI_14_4", "RVGIs_14_4"]) def test_slope_ext(self): self.data.ta.slope(append=True) @@ -185,48 +169,38 @@ class TestMomentumExtension(TestCase): def test_smi_ext(self): self.data.ta.smi(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["SMI_5_20_5", "SMIs_5_20_5", "SMIo_5_20_5"]) + self.assertEqual(list(self.data.columns[-3:]), ["SMI_5_20_5", "SMIs_5_20_5", "SMIo_5_20_5"]) self.data.ta.smi(scalar=10, append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual( - list(self.data.columns[-3:]), - ["SMI_5_20_5_10.0", "SMIs_5_20_5_10.0", "SMIo_5_20_5_10.0"], - ) + self.assertEqual(list(self.data.columns[-3:]), ["SMI_5_20_5_10.0", "SMIs_5_20_5_10.0", "SMIo_5_20_5_10.0"]) def test_squeeze_ext(self): self.data.ta.squeeze(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual( - list(self.data.columns[-4:]), - ["SQZ_20_2.0_20_1.5", "SQZ_ON", "SQZ_OFF", "SQZ_NO"], - ) + self.assertEqual(list(self.data.columns[-4:]), ["SQZ_20_2.0_20_1.5", "SQZ_ON", "SQZ_OFF", "SQZ_NO"]) self.data.ta.squeeze(tr=False, append=True) self.assertIsInstance(self.data, DataFrame) self.assertEqual( list(self.data.columns[-4:]), - ["SQZ_ON", "SQZ_OFF", "SQZ_NO", "SQZhlr_20_2.0_20_1.5"], + ["SQZ_ON", "SQZ_OFF", "SQZ_NO", "SQZhlr_20_2.0_20_1.5"] ) def test_stoch_ext(self): self.data.ta.stoch(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-2:]), - ["STOCHk_14_3_3", "STOCHd_14_3_3"]) + self.assertEqual(list(self.data.columns[-2:]), ["STOCHk_14_3_3", "STOCHd_14_3_3"]) def test_stochrsi_ext(self): self.data.ta.stochrsi(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-2:]), - ["STOCHRSIk_14_14_3_3", "STOCHRSId_14_14_3_3"]) + self.assertEqual(list(self.data.columns[-2:]), ["STOCHRSIk_14_14_3_3", "STOCHRSId_14_14_3_3"]) def test_trix_ext(self): self.data.ta.trix(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-2:]), - ["TRIX_30_9", "TRIXs_30_9"]) + self.assertEqual(list(self.data.columns[-2:]), ["TRIX_30_9", "TRIXs_30_9"]) def test_tsi_ext(self): self.data.ta.tsi(append=True) diff --git a/tests/test_ext_indicator_overlap_ext.py b/tests/test_ext_indicator_overlap_ext.py index 21f556c..4e7ccf7 100644 --- a/tests/test_ext_indicator_overlap_ext.py +++ b/tests/test_ext_indicator_overlap_ext.py @@ -6,7 +6,6 @@ from pandas import DataFrame class TestOverlapExtension(TestCase): - @classmethod def setUpClass(cls): cls.data = sample_data @@ -15,11 +14,9 @@ class TestOverlapExtension(TestCase): def tearDownClass(cls): del cls.data - def setUp(self): - pass + def setUp(self): pass + def tearDown(self): pass - def tearDown(self): - pass def test_dema_ext(self): self.data.ta.dema(append=True) @@ -39,8 +36,7 @@ class TestOverlapExtension(TestCase): def test_hilo_ext(self): self.data.ta.hilo(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["HILO_13_21", "HILOl_13_21", "HILOs_13_21"]) + self.assertEqual(list(self.data.columns[-3:]), ["HILO_13_21", "HILOl_13_21", "HILOs_13_21"]) def test_hl2_ext(self): self.data.ta.hl2(append=True) @@ -65,10 +61,7 @@ class TestOverlapExtension(TestCase): def test_ichimoku_ext(self): self.data.ta.ichimoku(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual( - list(self.data.columns[-5:]), - ["ISA_9", "ISB_26", "ITS_9", "IKS_26", "ICS_26"], - ) + self.assertEqual(list(self.data.columns[-5:]), ["ISA_9", "ISB_26", "ITS_9", "IKS_26", "ICS_26"]) def test_linreg_ext(self): self.data.ta.linreg(append=True) @@ -118,10 +111,7 @@ class TestOverlapExtension(TestCase): def test_supertrend_ext(self): self.data.ta.supertrend(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual( - list(self.data.columns[-4:]), - ["SUPERT_7_3.0", "SUPERTd_7_3.0", "SUPERTl_7_3.0", "SUPERTs_7_3.0"], - ) + self.assertEqual(list(self.data.columns[-4:]), ["SUPERT_7_3.0", "SUPERTd_7_3.0", "SUPERTl_7_3.0", "SUPERTs_7_3.0"]) def test_t3_ext(self): self.data.ta.t3(append=True) diff --git a/tests/test_ext_indicator_performance.py b/tests/test_ext_indicator_performance.py index 4a68861..380a833 100644 --- a/tests/test_ext_indicator_performance.py +++ b/tests/test_ext_indicator_performance.py @@ -6,23 +6,19 @@ from pandas import DataFrame class TestPerformaceExtension(TestCase): - @classmethod def setUpClass(cls): cls.data = sample_data - cls.islong = cls.data["close"] > pandas_ta.sma(cls.data["close"], - length=50) + cls.islong = cls.data["close"] > pandas_ta.sma(cls.data["close"], length=50) @classmethod def tearDownClass(cls): del cls.data del cls.islong - def setUp(self): - pass + def setUp(self): pass + def tearDown(self): pass - def tearDown(self): - pass def test_log_return_ext(self): self.data.ta.log_return(append=True) @@ -45,29 +41,17 @@ class TestPerformaceExtension(TestCase): self.assertEqual(self.data.columns[-1], "CUMPCTRET_1") def test_log_trend_return_ext(self): - self.data.ta.trend_return(trend=self.islong, - log=True, - cumulative=False, - append=True) + self.data.ta.trend_return(trend=self.islong, log=True, cumulative=False, append=True) self.assertIsInstance(self.data, DataFrame) def test_cum_log_trend_return_ext(self): - self.data.ta.trend_return(trend=self.islong, - log=True, - cumulative=True, - append=True) + self.data.ta.trend_return(trend=self.islong, log=True, cumulative=True, append=True) self.assertIsInstance(self.data, DataFrame) def test_pct_trend_return_ext(self): - self.data.ta.trend_return(trend=self.islong, - log=False, - cumulative=False, - append=True) + self.data.ta.trend_return(trend=self.islong, log=False, cumulative=False, append=True) self.assertIsInstance(self.data, DataFrame) def test_cum_pct_trend_return_ext(self): - self.data.ta.trend_return(trend=self.islong, - log=False, - cumulative=True, - append=True) + self.data.ta.trend_return(trend=self.islong, log=False, cumulative=True, append=True) self.assertIsInstance(self.data, DataFrame) diff --git a/tests/test_ext_indicator_statistics.py b/tests/test_ext_indicator_statistics.py index 5cff9b8..436b119 100644 --- a/tests/test_ext_indicator_statistics.py +++ b/tests/test_ext_indicator_statistics.py @@ -6,7 +6,6 @@ from pandas import DataFrame class TestStatisticsExtension(TestCase): - @classmethod def setUpClass(cls): cls.data = sample_data @@ -15,11 +14,9 @@ class TestStatisticsExtension(TestCase): def tearDownClass(cls): del cls.data - def setUp(self): - pass + def setUp(self): pass + def tearDown(self): pass - def tearDown(self): - pass def test_entropy_ext(self): self.data.ta.entropy(append=True) diff --git a/tests/test_ext_indicator_trend.py b/tests/test_ext_indicator_trend.py index e3df137..038a154 100644 --- a/tests/test_ext_indicator_trend.py +++ b/tests/test_ext_indicator_trend.py @@ -6,7 +6,6 @@ from pandas import DataFrame class TestTrendExtension(TestCase): - @classmethod def setUpClass(cls): cls.data = sample_data @@ -15,29 +14,24 @@ class TestTrendExtension(TestCase): def tearDownClass(cls): del cls.data - def setUp(self): - pass + def setUp(self): pass + def tearDown(self): pass - def tearDown(self): - pass def test_adx_ext(self): self.data.ta.adx(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["ADX_14", "DMP_14", "DMN_14"]) + self.assertEqual(list(self.data.columns[-3:]), ["ADX_14", "DMP_14", "DMN_14"]) def test_amat_ext(self): self.data.ta.amat(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-2:]), - ["AMAT_LR_2", "AMAT_SR_2"]) + self.assertEqual(list(self.data.columns[-2:]), ["AMAT_LR_2", "AMAT_SR_2"]) def test_aroon_ext(self): self.data.ta.aroon(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["AROOND_14", "AROONU_14", "AROONOSC_14"]) + self.assertEqual(list(self.data.columns[-3:]), ["AROOND_14", "AROONU_14", "AROONOSC_14"]) def test_chop_ext(self): self.data.ta.chop(append=True) @@ -75,8 +69,7 @@ class TestTrendExtension(TestCase): def test_long_run_ext(self): # Nothing passed, return self - self.assertEqual( - self.data.ta.long_run(append=True).shape, self.data.shape) + self.assertEqual(self.data.ta.long_run(append=True).shape, self.data.shape) fast = self.data.ta.ema(8) slow = self.data.ta.ema(21) @@ -88,12 +81,7 @@ class TestTrendExtension(TestCase): self.data.ta.psar(append=True) self.assertIsInstance(self.data, DataFrame) self.assertEqual( - list(self.data.columns[-4:]), - [ - "PSARl_0.02_0.2", "PSARs_0.02_0.2", "PSARaf_0.02_0.2", - "PSARr_0.02_0.2" - ], - ) + list(self.data.columns[-4:]), ["PSARl_0.02_0.2", "PSARs_0.02_0.2", "PSARaf_0.02_0.2", "PSARr_0.02_0.2"]) def test_qstick_ext(self): self.data.ta.qstick(append=True) diff --git a/tests/test_ext_indicator_volatility.py b/tests/test_ext_indicator_volatility.py index fc38a63..3b7943d 100644 --- a/tests/test_ext_indicator_volatility.py +++ b/tests/test_ext_indicator_volatility.py @@ -6,7 +6,6 @@ from pandas import DataFrame class TestVolatilityExtension(TestCase): - @classmethod def setUpClass(cls): cls.data = sample_data @@ -15,25 +14,19 @@ class TestVolatilityExtension(TestCase): def tearDownClass(cls): del cls.data - def setUp(self): - pass + def setUp(self): pass + def tearDown(self): pass - def tearDown(self): - pass def test_aberration_ext(self): self.data.ta.aberration(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual( - list(self.data.columns[-4:]), - ["ABER_ZG_5_15", "ABER_SG_5_15", "ABER_XG_5_15", "ABER_ATR_5_15"], - ) + self.assertEqual(list(self.data.columns[-4:]), ["ABER_ZG_5_15", "ABER_SG_5_15", "ABER_XG_5_15", "ABER_ATR_5_15"]) def test_accbands_ext(self): self.data.ta.accbands(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["ACCBL_20", "ACCBM_20", "ACCBU_20"]) + self.assertEqual(list(self.data.columns[-3:]), ["ACCBL_20", "ACCBM_20", "ACCBU_20"]) def test_atr_ext(self): self.data.ta.atr(append=True) @@ -43,20 +36,17 @@ class TestVolatilityExtension(TestCase): def test_bbands_ext(self): self.data.ta.bbands(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["BBL_5_2.0", "BBM_5_2.0", "BBU_5_2.0"]) + self.assertEqual(list(self.data.columns[-3:]), ["BBL_5_2.0", "BBM_5_2.0", "BBU_5_2.0"]) def test_donchian_ext(self): self.data.ta.donchian(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["DCL_20_20", "DCM_20_20", "DCU_20_20"]) + self.assertEqual(list(self.data.columns[-3:]), ["DCL_20_20", "DCM_20_20", "DCU_20_20"]) def test_kc_ext(self): self.data.ta.kc(append=True) self.assertIsInstance(self.data, DataFrame) - self.assertEqual(list(self.data.columns[-3:]), - ["KCL_20_2", "KCB_20_2", "KCU_20_2"]) + self.assertEqual(list(self.data.columns[-3:]), ["KCL_20_2", "KCB_20_2", "KCU_20_2"]) def test_massi_ext(self): self.data.ta.massi(append=True) diff --git a/tests/test_ext_indicator_volume.py b/tests/test_ext_indicator_volume.py index 96d4278..956d768 100644 --- a/tests/test_ext_indicator_volume.py +++ b/tests/test_ext_indicator_volume.py @@ -6,7 +6,6 @@ from pandas import DataFrame class TestVolumeExtension(TestCase): - @classmethod def setUpClass(cls): cls.data = sample_data @@ -17,11 +16,9 @@ class TestVolumeExtension(TestCase): del cls.data del cls.open - def setUp(self): - pass + def setUp(self): pass + def tearDown(self): pass - def tearDown(self): - pass def test_ad_ext(self): self.data.ta.ad(append=True) diff --git a/tests/test_indicator_candle.py b/tests/test_indicator_candle.py index b1903d2..4a2620d 100644 --- a/tests/test_indicator_candle.py +++ b/tests/test_indicator_candle.py @@ -1,10 +1,4 @@ -from .config import ( - error_analysis, - sample_data, - CORRELATION, - CORRELATION_THRESHOLD, - VERBOSE, -) +from .config import error_analysis, sample_data, CORRELATION, CORRELATION_THRESHOLD, VERBOSE from .context import pandas_ta from unittest import TestCase, skip @@ -58,23 +52,16 @@ class TestCandle(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) def test_cdl_inside(self): - result = pandas_ta.cdl_inside(self.open, self.high, self.low, - self.close) + result = pandas_ta.cdl_inside(self.open, self.high, self.low, self.close) self.assertIsInstance(result, Series) self.assertEqual(result.name, "CDL_INSIDE") - result = pandas_ta.cdl_inside(self.open, - self.high, - self.low, - self.close, - asbool=True) + result = pandas_ta.cdl_inside(self.open, self.high, self.low, self.close, asbool=True) self.assertIsInstance(result, Series) self.assertEqual(result.name, "CDL_INSIDE") diff --git a/tests/test_indicator_momentum.py b/tests/test_indicator_momentum.py index a1b462b..65b9baf 100644 --- a/tests/test_indicator_momentum.py +++ b/tests/test_indicator_momentum.py @@ -1,10 +1,4 @@ -from .config import ( - error_analysis, - sample_data, - CORRELATION, - CORRELATION_THRESHOLD, - VERBOSE, -) +from .config import error_analysis, sample_data, CORRELATION, CORRELATION_THRESHOLD, VERBOSE from .context import pandas_ta from unittest import TestCase, skip @@ -83,9 +77,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -105,9 +97,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -127,9 +117,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -154,9 +142,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -186,10 +172,7 @@ class TestMomentum(TestCase): self.assertIsInstance(result, Series) self.assertEqual(result.name, "INERTIA_20_14") - result = pandas_ta.inertia(self.close, - self.high, - self.low, - refined=True) + result = pandas_ta.inertia(self.close, self.high, self.low, refined=True) self.assertIsInstance(result, Series) self.assertEqual(result.name, "INERTIAr_20_14") @@ -214,39 +197,26 @@ class TestMomentum(TestCase): try: expected = tal.MACD(self.close) - expecteddf = DataFrame({ - "MACD_12_26_9": expected[0], - "MACDh_12_26_9": expected[2], - "MACDs_12_26_9": expected[1], - }) + expecteddf = DataFrame({"MACD_12_26_9": expected[0], "MACDh_12_26_9": expected[2], "MACDs_12_26_9": expected[1]}) pdt.assert_frame_equal(result, expecteddf) except AssertionError as ae: try: - macd_corr = pandas_ta.utils.df_error_analysis( - result.iloc[:, 0], expecteddf.iloc[:, 0], col=CORRELATION) + macd_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 0], expecteddf.iloc[:, 0], col=CORRELATION) self.assertGreater(macd_corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result.iloc[:, 0], CORRELATION, ex) try: - history_corr = pandas_ta.utils.df_error_analysis( - result.iloc[:, 1], expecteddf.iloc[:, 1], col=CORRELATION) + history_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 1], expecteddf.iloc[:, 1], col=CORRELATION) self.assertGreater(history_corr, CORRELATION_THRESHOLD) except Exception as ex: - error_analysis(result.iloc[:, 1], - CORRELATION, - ex, - newline=False) + error_analysis(result.iloc[:, 1], CORRELATION, ex, newline=False) try: - signal_corr = pandas_ta.utils.df_error_analysis( - result.iloc[:, 2], expecteddf.iloc[:, 2], col=CORRELATION) + signal_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 2], expecteddf.iloc[:, 2], col=CORRELATION) self.assertGreater(signal_corr, CORRELATION_THRESHOLD) except Exception as ex: - error_analysis(result.iloc[:, 2], - CORRELATION, - ex, - newline=False) + error_analysis(result.iloc[:, 2], CORRELATION, ex, newline=False) def test_mom(self): result = pandas_ta.mom(self.close) @@ -258,9 +228,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -277,14 +245,10 @@ class TestMomentum(TestCase): try: expected = tal.PPO(self.close) - pdt.assert_series_equal(result["PPO_12_26_9"], - expected, - check_names=False) + pdt.assert_series_equal(result["PPO_12_26_9"], expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result["PPO_12_26_9"], - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result["PPO_12_26_9"], expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result["PPO_12_26_9"], CORRELATION, ex) @@ -309,9 +273,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -326,9 +288,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -374,18 +334,11 @@ class TestMomentum(TestCase): self.assertIsInstance(result, DataFrame) self.assertEqual(result.name, "SQZhlr_20_2.0_20_1.5") - result = pandas_ta.squeeze(self.high, - self.low, - self.close, - lazybear=True) + result = pandas_ta.squeeze(self.high, self.low, self.close, lazybear=True) self.assertIsInstance(result, DataFrame) self.assertEqual(result.name, "SQZ_20_2.0_20_1.5_LB") - result = pandas_ta.squeeze(self.high, - self.low, - self.close, - tr=False, - lazybear=True) + result = pandas_ta.squeeze(self.high, self.low, self.close, tr=False, lazybear=True) self.assertIsInstance(result, DataFrame) self.assertEqual(result.name, "SQZhlr_20_2.0_20_1.5_LB") @@ -422,9 +375,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -439,9 +390,7 @@ class TestMomentum(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) diff --git a/tests/test_indicator_overlap.py b/tests/test_indicator_overlap.py index 75b161c..9d59fd8 100644 --- a/tests/test_indicator_overlap.py +++ b/tests/test_indicator_overlap.py @@ -1,10 +1,4 @@ -from .config import ( - CORRELATION, - CORRELATION_THRESHOLD, - error_analysis, - sample_data, - VERBOSE, -) +from .config import CORRELATION, CORRELATION_THRESHOLD, error_analysis, sample_data, VERBOSE from .context import pandas_ta from unittest import TestCase @@ -54,9 +48,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -71,9 +63,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -103,9 +93,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -137,9 +125,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -154,9 +140,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -171,9 +155,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -193,9 +175,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -210,9 +190,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -227,9 +205,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -264,9 +240,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -291,9 +265,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -308,9 +280,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -325,9 +295,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -352,9 +320,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -369,9 +335,7 @@ class TestOverlap(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) diff --git a/tests/test_indicator_performance.py b/tests/test_indicator_performance.py index 1f92362..5eb7e81 100644 --- a/tests/test_indicator_performance.py +++ b/tests/test_indicator_performance.py @@ -48,45 +48,25 @@ class TestPerformace(TestCase): self.assertEqual(result.name, "CUMPCTRET_1") def test_log_trend_return(self): - result = pandas_ta.trend_return(self.close, - self.islong, - log=True, - cumulative=False) + result = pandas_ta.trend_return(self.close, self.islong, log=True, cumulative=False) self.assertEqual(result.name, "LTR") def test_cum_log_trend_return(self): - result = pandas_ta.trend_return(self.close, - self.islong, - log=True, - cumulative=True) + result = pandas_ta.trend_return(self.close, self.islong, log=True, cumulative=True) self.assertEqual(result.name, "CLTR") def test_variable_cum_log_trend_return(self): - result = pandas_ta.trend_return(self.close, - self.islong, - log=True, - cumulative=True, - variable=True) + result = pandas_ta.trend_return(self.close, self.islong, log=True, cumulative=True, variable=True) self.assertEqual(result.name, "CLTR") def test_pct_trend_return(self): - result = pandas_ta.trend_return(self.close, - self.islong, - log=False, - cumulative=False) + result = pandas_ta.trend_return(self.close, self.islong, log=False, cumulative=False) self.assertEqual(result.name, "PTR") def test_cum_pct_trend_return(self): - result = pandas_ta.trend_return(self.close, - self.islong, - log=False, - cumulative=True) + result = pandas_ta.trend_return(self.close, self.islong, log=False, cumulative=True) self.assertEqual(result.name, "CPTR") def test_variable_pct_log_trend_return(self): - result = pandas_ta.trend_return(self.close, - self.islong, - log=False, - cumulative=True, - variable=True) + result = pandas_ta.trend_return(self.close, self.islong, log=False, cumulative=True, variable=True) self.assertEqual(result.name, "CPTR") diff --git a/tests/test_indicator_statistics.py b/tests/test_indicator_statistics.py index 75ee92c..c0fae43 100644 --- a/tests/test_indicator_statistics.py +++ b/tests/test_indicator_statistics.py @@ -1,10 +1,4 @@ -from .config import ( - error_analysis, - sample_data, - CORRELATION, - CORRELATION_THRESHOLD, - VERBOSE, -) +from .config import error_analysis, sample_data, CORRELATION, CORRELATION_THRESHOLD, VERBOSE from .context import pandas_ta from unittest import TestCase, skip @@ -83,9 +77,7 @@ class TestStatistics(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -100,9 +92,7 @@ class TestStatistics(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) diff --git a/tests/test_indicator_trend.py b/tests/test_indicator_trend.py index faf6b34..ade9bee 100644 --- a/tests/test_indicator_trend.py +++ b/tests/test_indicator_trend.py @@ -1,10 +1,4 @@ -from .config import ( - error_analysis, - sample_data, - CORRELATION, - CORRELATION_THRESHOLD, - VERBOSE, -) +from .config import error_analysis, sample_data, CORRELATION, CORRELATION_THRESHOLD, VERBOSE from .context import pandas_ta from unittest import TestCase, skip @@ -53,9 +47,7 @@ class TestTrend(TestCase): pdt.assert_series_equal(result.iloc[:, 0], expected) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 0], - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 0], expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -72,28 +64,20 @@ class TestTrend(TestCase): try: expected = tal.AROON(self.high, self.low) - expecteddf = DataFrame({ - "AROOND_14": expected[0], - "AROONU_14": expected[1] - }) + expecteddf = DataFrame({"AROOND_14": expected[0], "AROONU_14": expected[1]}) pdt.assert_frame_equal(result, expecteddf) except AssertionError as ae: try: - aroond_corr = pandas_ta.utils.df_error_analysis( - result.iloc[:, 0], expecteddf.iloc[:, 0], col=CORRELATION) + aroond_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 0], expecteddf.iloc[:, 0], col=CORRELATION) self.assertGreater(aroond_corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result.iloc[:, 0], CORRELATION, ex) try: - aroonu_corr = pandas_ta.utils.df_error_analysis( - result.iloc[:, 1], expecteddf.iloc[:, 1], col=CORRELATION) + aroonu_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 1], expecteddf.iloc[:, 1], col=CORRELATION) self.assertGreater(aroonu_corr, CORRELATION_THRESHOLD) except Exception as ex: - error_analysis(result.iloc[:, 1], - CORRELATION, - ex, - newline=False) + error_analysis(result.iloc[:, 1], CORRELATION, ex, newline=False) def test_aroon_osc(self): result = pandas_ta.aroon(self.high, self.low) @@ -103,10 +87,7 @@ class TestTrend(TestCase): pdt.assert_series_equal(result.iloc[:, 2], expected) except AssertionError as ae: try: - aroond_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, - 2], - expected, - col=CORRELATION) + aroond_corr = pandas_ta.utils.df_error_analysis(result.iloc[:,2], expected,col=CORRELATION) self.assertGreater(aroond_corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result.iloc[:, 0], CORRELATION, ex) @@ -165,9 +146,7 @@ class TestTrend(TestCase): pdt.assert_series_equal(psar, expected) except AssertionError as ae: try: - psar_corr = pandas_ta.utils.df_error_analysis(psar, - expected, - col=CORRELATION) + psar_corr = pandas_ta.utils.df_error_analysis(psar, expected, col=CORRELATION) self.assertGreater(psar_corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(psar, CORRELATION, ex) diff --git a/tests/test_indicator_volatility.py b/tests/test_indicator_volatility.py index 72c9712..17f0ef4 100644 --- a/tests/test_indicator_volatility.py +++ b/tests/test_indicator_volatility.py @@ -1,10 +1,4 @@ -from .config import ( - error_analysis, - sample_data, - CORRELATION, - CORRELATION_THRESHOLD, - VERBOSE, -) +from .config import error_analysis, sample_data, CORRELATION, CORRELATION_THRESHOLD, VERBOSE from .context import pandas_ta from unittest import TestCase, skip @@ -63,9 +57,7 @@ class TestVolatility(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -77,55 +69,33 @@ class TestVolatility(TestCase): try: expected = tal.BBANDS(self.close) - expecteddf = DataFrame({ - "BBL_5_2.0": expected[0], - "BBM_5_2.0": expected[1], - "BBU_5_2.0": expected[2], - }) + expecteddf = DataFrame({"BBL_5_2.0": expected[0], "BBM_5_2.0": expected[1], "BBU_5_2.0": expected[2]}) pdt.assert_frame_equal(result, expecteddf) except AssertionError as ae: try: - bbl_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 0], - expecteddf.iloc[:, - 0], - col=CORRELATION) + bbl_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 0], expecteddf.iloc[:,0], col=CORRELATION) self.assertGreater(bbl_corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result.iloc[:, 0], CORRELATION, ex) try: - bbm_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 1], - expecteddf.iloc[:, - 1], - col=CORRELATION) + bbm_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 1], expecteddf.iloc[:,1], col=CORRELATION) self.assertGreater(bbm_corr, CORRELATION_THRESHOLD) except Exception as ex: - error_analysis(result.iloc[:, 1], - CORRELATION, - ex, - newline=False) + error_analysis(result.iloc[:, 1], CORRELATION, ex, newline=False) try: - bbu_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 2], - expecteddf.iloc[:, - 2], - col=CORRELATION) + bbu_corr = pandas_ta.utils.df_error_analysis(result.iloc[:, 2], expecteddf.iloc[:,2], col=CORRELATION) self.assertGreater(bbu_corr, CORRELATION_THRESHOLD) except Exception as ex: - error_analysis(result.iloc[:, 2], - CORRELATION, - ex, - newline=False) + error_analysis(result.iloc[:, 2], CORRELATION, ex, newline=False) def test_donchian(self): result = pandas_ta.donchian(self.high, self.low) self.assertIsInstance(result, DataFrame) self.assertEqual(result.name, "DC_20_20") - result = pandas_ta.donchian(self.high, - self.low, - lower_length=20, - upper_length=5) + result = pandas_ta.donchian(self.high, self.low, lower_length=20, upper_length=5) self.assertIsInstance(result, DataFrame) self.assertEqual(result.name, "DC_20_5") @@ -153,9 +123,7 @@ class TestVolatility(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -193,9 +161,7 @@ class TestVolatility(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) diff --git a/tests/test_indicator_volume.py b/tests/test_indicator_volume.py index 44e9ad0..fd2765f 100644 --- a/tests/test_indicator_volume.py +++ b/tests/test_indicator_volume.py @@ -1,10 +1,4 @@ -from .config import ( - error_analysis, - sample_data, - CORRELATION, - CORRELATION_THRESHOLD, - VERBOSE, -) +from .config import error_analysis, sample_data, CORRELATION, CORRELATION_THRESHOLD, VERBOSE from .context import pandas_ta from unittest import TestCase, skip @@ -53,16 +47,13 @@ class TestVolume(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) def test_ad_open(self): - result = pandas_ta.ad(self.high, self.low, self.close, self.volume_, - self.open) + result = pandas_ta.ad(self.high, self.low, self.close, self.volume_, self.open) self.assertIsInstance(result, Series) self.assertEqual(result.name, "ADo") @@ -76,9 +67,7 @@ class TestVolume(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -113,9 +102,7 @@ class TestVolume(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) @@ -135,9 +122,7 @@ class TestVolume(TestCase): pdt.assert_series_equal(result, expected, check_names=False) except AssertionError as ae: try: - corr = pandas_ta.utils.df_error_analysis(result, - expected, - col=CORRELATION) + corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION) self.assertGreater(corr, CORRELATION_THRESHOLD) except Exception as ex: error_analysis(result, CORRELATION, ex) diff --git a/tests/test_strategy.py b/tests/test_strategy.py index fa5bae8..fe0d5ac 100644 --- a/tests/test_strategy.py +++ b/tests/test_strategy.py @@ -48,10 +48,8 @@ class TestStrategyMethods(TestCase): self.init_cols = len(self.data.columns) self.time_diff = 0 self.result = None - if verbose: - print() - if timed: - self.stime = perf_counter() + if verbose: print() + if timed: self.stime = perf_counter() def tearDown(self): if timed: @@ -72,64 +70,35 @@ class TestStrategyMethods(TestCase): @skip def test_all_strategy(self): - self.data.ta.strategy(pandas_ta.AllStrategy, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(pandas_ta.AllStrategy, verbose=verbose, timed=strategy_timed) @skip def test_all_name_strategy(self): self.category = "All" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) # @skip def test_candles_category(self): self.category = "Candles" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) # @skip def test_common(self): self.category = "Common" - self.data.ta.strategy(pandas_ta.CommonStrategy, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(pandas_ta.CommonStrategy, verbose=verbose, timed=strategy_timed) # @skip def test_custom_a(self): self.category = "Custom A" momo_bands_sma_ta = [ - { - "kind": "rsi" - }, # 1 - { - "kind": "macd" - }, # 3 - { - "kind": "sma", - "length": 50 - }, # 1 - { - "kind": "sma", - "length": 200 - }, # 1 - { - "kind": "bbands", - "length": 20 - }, # 3 - { - "kind": "log_return", - "cumulative": True - }, # 1 - { - "kind": "ema", - "close": "CUMLOGRET_1", - "length": 5, - "suffix": "CLR" - }, + {"kind": "rsi"}, # 1 + {"kind": "macd"}, # 3 + {"kind": "sma", "length": 50}, # 1 + {"kind": "sma", "length": 200 }, # 1 + {"kind": "bbands", "length": 20}, # 3 + {"kind": "log_return", "cumulative": True}, # 1 + {"kind": "ema", "close": "CUMLOGRET_1", "length": 5, "suffix": "CLR"} ] custom = pandas_ta.Strategy( @@ -144,20 +113,14 @@ class TestStrategyMethods(TestCase): self.category = "Custom B" custom_args_ta = [ - { - "kind": "ema", - "params": (5,) - }, - { - "kind": "fisher", - "params": (13, 7) - }, + {"kind": "ema", "params": (5,)}, + {"kind": "fisher", "params": (13, 7)} ] custom = pandas_ta.Strategy( "Custom Args Tuple", custom_args_ta, - "Allow for easy filling in indicator arguments by argument placement.", + "Allow for easy filling in indicator arguments by argument placement." ) self.data.ta.strategy(custom, verbose=verbose, timed=strategy_timed) @@ -189,48 +152,34 @@ class TestStrategyMethods(TestCase): # @skip def test_momentum_category(self): self.category = "Momentum" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) # @skip def test_overlap_category(self): self.category = "Overlap" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) # @skip def test_performance_category(self): self.category = "Performance" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) # @skip def test_statistics_category(self): self.category = "Statistics" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) # @skip def test_trend_category(self): self.category = "Trend" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) # @skip def test_volatility_category(self): self.category = "Volatility" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) # @skip def test_volume_category(self): self.category = "Volume" - self.data.ta.strategy(self.category, - verbose=verbose, - timed=strategy_timed) + self.data.ta.strategy(self.category, verbose=verbose, timed=strategy_timed) diff --git a/tests/test_utils.py b/tests/test_utils.py index 72fbb00..f4a051b 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -91,8 +91,7 @@ class TestUtilities(TestCase): self.assertEqual(result.name, "a_A_0") npt.assert_array_equal(result, self.crosseddf["c"]) - result = self.utils.above_value(self.crosseddf["a"], - self.crosseddf["zero"]) + result = self.utils.above_value(self.crosseddf["a"], self.crosseddf["zero"]) self.assertIsNone(result) def test_below(self): @@ -112,8 +111,7 @@ class TestUtilities(TestCase): self.assertEqual(result.name, "a_B_0") npt.assert_array_equal(result, self.crosseddf["b"]) - result = self.utils.below_value(self.crosseddf["a"], - self.crosseddf["zero"]) + result = self.utils.below_value(self.crosseddf["a"], self.crosseddf["zero"]) self.assertIsNone(result) def test_combination(self): @@ -164,36 +162,19 @@ class TestUtilities(TestCase): npt.assert_array_equal(self.utils.fibonacci(zero=True), np.array([0, 1, 1])) npt.assert_array_equal(self.utils.fibonacci(zero=False), np.array([1, 1])) - npt.assert_array_equal( - self.utils.fibonacci(n=0, zero=True, weighted=False), np.array([0])) - npt.assert_array_equal( - self.utils.fibonacci(n=0, zero=False, weighted=False), - np.array([1])) + npt.assert_array_equal(self.utils.fibonacci(n=0, zero=True, weighted=False), np.array([0])) + npt.assert_array_equal(self.utils.fibonacci(n=0, zero=False, weighted=False), np.array([1])) - npt.assert_array_equal( - self.utils.fibonacci(n=5, zero=True, weighted=False), - np.array([0, 1, 1, 2, 3, 5]), - ) - npt.assert_array_equal( - self.utils.fibonacci(n=5, zero=False, weighted=False), - np.array([1, 1, 2, 3, 5]), - ) + npt.assert_array_equal(self.utils.fibonacci(n=5, zero=True, weighted=False), np.array([0, 1, 1, 2, 3, 5])) + npt.assert_array_equal(self.utils.fibonacci(n=5, zero=False, weighted=False), np.array([1, 1, 2, 3, 5])) def test_fibonacci_weighted(self): self.assertIs(type(self.utils.fibonacci(zero=True, weighted=True)), np.ndarray) - npt.assert_array_equal( - self.utils.fibonacci(n=0, zero=True, weighted=True), np.array([0])) - npt.assert_array_equal( - self.utils.fibonacci(n=0, zero=False, weighted=True), np.array([1])) + npt.assert_array_equal(self.utils.fibonacci(n=0, zero=True, weighted=True), np.array([0])) + npt.assert_array_equal(self.utils.fibonacci(n=0, zero=False, weighted=True), np.array([1])) - npt.assert_allclose( - self.utils.fibonacci(n=5, zero=True, weighted=True), - np.array([0, 1 / 12, 1 / 12, 1 / 6, 1 / 4, 5 / 12]), - ) - npt.assert_allclose( - self.utils.fibonacci(n=5, zero=False, weighted=True), - np.array([1 / 12, 1 / 12, 1 / 6, 1 / 4, 5 / 12]), - ) + npt.assert_allclose(self.utils.fibonacci(n=5, zero=True, weighted=True), np.array([0, 1 / 12, 1 / 12, 1 / 6, 1 / 4, 5 / 12])) + npt.assert_allclose(self.utils.fibonacci(n=5, zero=False, weighted=True), np.array([1 / 12, 1 / 12, 1 / 6, 1 / 4, 5 / 12])) def test_get_time(self): result = self.utils.get_time(to_string=True) @@ -225,43 +206,32 @@ class TestUtilities(TestCase): array_1 = np.array([1]) npt.assert_array_equal(self.utils.pascals_triangle(), array_1) npt.assert_array_equal(self.utils.pascals_triangle(weighted=True), array_1) - npt.assert_array_equal( - self.utils.pascals_triangle(weighted=True, inverse=True), - np.array([0])) + npt.assert_array_equal(self.utils.pascals_triangle(weighted=True, inverse=True), np.array([0])) - array_5 = self.utils.pascals_triangle( - n=5) # or np.array([1, 5, 10, 10, 5, 1]) + array_5 = self.utils.pascals_triangle(n=5) # or np.array([1, 5, 10, 10, 5, 1]) array_5w = array_5 / np.sum(array_5) array_5iw = 1 - array_5w npt.assert_array_equal(self.utils.pascals_triangle(n=-5), array_5) npt.assert_array_equal(self.utils.pascals_triangle(n=-5, weighted=True), array_5w) - npt.assert_array_equal( - self.utils.pascals_triangle(n=-5, weighted=True, inverse=True), - array_5iw) + npt.assert_array_equal(self.utils.pascals_triangle(n=-5, weighted=True, inverse=True), array_5iw) npt.assert_array_equal(self.utils.pascals_triangle(n=5), array_5) npt.assert_array_equal(self.utils.pascals_triangle(n=5, weighted=True), array_5w) - npt.assert_array_equal( - self.utils.pascals_triangle(n=5, weighted=True, inverse=True), - array_5iw) + npt.assert_array_equal(self.utils.pascals_triangle(n=5, weighted=True, inverse=True), array_5iw) def test_symmetric_triangle(self): npt.assert_array_equal(self.utils.symmetric_triangle(), np.array([1,1])) npt.assert_array_equal(self.utils.symmetric_triangle(weighted=True), np.array([0.5, 0.5])) - array_4 = self.utils.symmetric_triangle( - n=4) # or np.array([1, 2, 2, 1]) + array_4 = self.utils.symmetric_triangle(n=4) # or np.array([1, 2, 2, 1]) array_4w = array_4 / np.sum(array_4) npt.assert_array_equal(self.utils.symmetric_triangle(n=4), array_4) - npt.assert_array_equal( - self.utils.symmetric_triangle(n=4, weighted=True), array_4w) + npt.assert_array_equal(self.utils.symmetric_triangle(n=4, weighted=True), array_4w) - array_5 = self.utils.symmetric_triangle( - n=5) # or np.array([1, 2, 3, 2, 1]) + array_5 = self.utils.symmetric_triangle(n=5) # or np.array([1, 2, 3, 2, 1]) array_5w = array_5 / np.sum(array_5) npt.assert_array_equal(self.utils.symmetric_triangle(n=5), array_5) - npt.assert_array_equal( - self.utils.symmetric_triangle(n=5, weighted=True), array_5w) + npt.assert_array_equal(self.utils.symmetric_triangle(n=5, weighted=True), array_5w) def test_zero(self): self.assertEqual(self.utils.zero(-0.0000000000000001), 0)