jerry/OpenBB
1
0
Fork 0
mirror of https://github.com/OpenBB-finance/OpenBB.git synced 2026-10-28 04:52:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix python interface QA and TA

Browse Source
This commit is contained in:
Igor Radovanovic
2023-10-06 23:28:08 +02:00
parent ea4f4a7e2d
commit 8eb149726c
3 changed files with 280 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
openbb_platform/extensions/econometrics/integration/test_econometrics_python.py
View File

@@ -9,7 +9,6 @@ from openbb_core.app.model.obbject import OBBject
@pytest.fixture(scope="session")
def obb(pytestconfig):
"""Fixture to setup obb."""
if pytestconfig.getoption("markexpr") != "not integration":
import openbb

119
openbb_platform/extensions/qa/integration/test_qa_python.py
View File

@@ -1,5 +1,6 @@
"""Test qa extension."""
import random
from typing import Literal
import pytest
from openbb_core.app.model.obbject import OBBject
@@ -8,7 +9,6 @@ from openbb_core.app.model.obbject import OBBject
@pytest.fixture(scope="session")
def obb(pytestconfig):
"""Fixture to setup obb."""
if pytestconfig.getoption("markexpr") != "not integration":
import openbb
@@ -49,16 +49,22 @@ def get_crypto_data():
return data["crypto_data"]
def get_data(menu: Literal["stocks", "crypto"]):
funcs = {"stocks": get_stocks_data, "crypto": get_crypto_data}
return funcs[menu]()
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "target": "close"}),
({"data": get_crypto_data(), "target": "high"}),
({"data": "", "target": "close"}, "stocks"),
({"data": "", "target": "high"}, "crypto"),
],
)
@pytest.mark.integration
def test_qa_normality(params, obb):
def test_qa_normality(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.normality(**params)
assert result
@@ -66,15 +72,16 @@ def test_qa_normality(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "target": "close"}),
({"data": get_crypto_data(), "target": "high"}),
({"data": "", "target": "close"}, "stocks"),
({"data": "", "target": "high"}, "crypto"),
],
)
@pytest.mark.integration
def test_qa_capm(params, obb):
def test_qa_capm(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.capm(**params)
assert result
@@ -82,29 +89,32 @@ def test_qa_capm(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "close",
"threshold_start": "",
"threshold_end": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"threshold_start": "0.1",
"threshold_end": "1.6",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_qa_om(params, obb):
def test_qa_om(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.om(**params)
assert result
@@ -112,15 +122,16 @@ def test_qa_om(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "target": "close", "window": "5"}),
({"data": get_crypto_data(), "target": "high", "window": "10"}),
({"data": "", "target": "close", "window": "5"}, "stocks"),
({"data": "", "target": "high", "window": "10"}, "crypto"),
],
)
@pytest.mark.integration
def test_qa_kurtosis(params, obb):
def test_qa_kurtosis(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.kurtosis(**params)
assert result
@@ -129,29 +140,32 @@ def test_qa_kurtosis(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "close",
"fuller_reg": "c",
"kpss_reg": "ct",
}
},
"stocks",
),
(
{
"data": get_stocks_data(),
"data": "",
"target": "high",
"fuller_reg": "ct",
"kpss_reg": "c",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_qa_unitroot(params, obb):
def test_qa_unitroot(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.unitroot(**params)
assert result
@@ -159,15 +173,16 @@ def test_qa_unitroot(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "target": "close", "rfr": "", "window": ""}),
({"data": get_crypto_data(), "target": "high", "rfr": "0.5", "window": "250"}),
({"data": "", "target": "close", "rfr": "", "window": ""}, "stocks"),
({"data": "", "target": "high", "rfr": "0.5", "window": "250"}, "crypto"),
],
)
@pytest.mark.integration
def test_qa_sh(params, obb):
def test_qa_sh(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.sh(**params)
assert result
@@ -175,31 +190,34 @@ def test_qa_sh(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "close",
"target_return": "",
"window": "",
"adjusted": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "close",
"target_return": "0.5",
"window": "275",
"adjusted": "true",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_qa_so(params, obb):
def test_qa_so(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.so(**params)
assert result
@@ -207,14 +225,15 @@ def test_qa_so(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "target": "close", "window": "220"}),
({"data": "", "target": "close", "window": "220"}, "stocks"),
],
)
@pytest.mark.integration
def test_qa_skew(params, obb):
def test_qa_skew(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.skew(**params)
assert result
@@ -223,29 +242,32 @@ def test_qa_skew(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "close",
"window": "10",
"quantile_pct": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"window": "50",
"quantile_pct": "0.6",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_qa_quantile(params, obb):
def test_qa_quantile(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.quantile(**params)
assert result
@@ -254,15 +276,16 @@ def test_qa_quantile(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "target": "close"}),
({"data": get_crypto_data(), "target": "high"}),
({"data": "", "target": "close"}, "stocks"),
({"data": "", "target": "high"}, "crypto"),
],
)
@pytest.mark.integration
def test_qa_summary(params, obb):
def test_qa_summary(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.qa.summary(**params)
assert result

349
openbb_platform/extensions/ta/integration/test_ta_python.py
View File

@@ -1,5 +1,6 @@
"""Test ta extension."""
import random
from typing import Literal
import pytest
from openbb_core.app.model.obbject import OBBject
@@ -8,7 +9,6 @@ from openbb_core.app.model.obbject import OBBject
@pytest.fixture(scope="session")
def obb(pytestconfig):
"""Fixture to setup obb."""
if pytestconfig.getoption("markexpr") != "not integration":
import openbb
@@ -49,34 +49,42 @@ def get_crypto_data():
return data["crypto_data"]
def get_data(menu: Literal["stocks", "crypto"]):
funcs = {"stocks": get_stocks_data, "crypto": get_crypto_data}
return funcs[menu]()
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"length": "",
"mamode": "",
"drift": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"length": "15",
"mamode": "rma",
"drift": "2",
"offset": "1",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_atr(params, obb):
def test_ta_atr(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.atr(**params)
assert result
@@ -85,33 +93,36 @@ def test_ta_atr(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"close_column": "",
"period": "",
"start_date": "",
"end_date": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"close_column": "adj_close",
"period": "125",
"start_date": "",
"end_date": "",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_fib(params, obb):
def test_ta_fib(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.fib(**params)
assert result
@@ -120,15 +131,16 @@ def test_ta_fib(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "index": "", "offset": ""}),
({"data": get_crypto_data(), "index": "date", "offset": "1"}),
({"data": "", "index": "", "offset": ""}, "stocks"),
({"data": "", "index": "date", "offset": "1"}, "crypto"),
],
)
@pytest.mark.integration
def test_ta_obv(params, obb):
def test_ta_obv(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.obv(**params)
assert result
@@ -137,15 +149,16 @@ def test_ta_obv(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "index": "", "length": "", "signal": ""}),
({"data": get_crypto_data(), "index": "date", "length": "15", "signal": "2"}),
({"data": "", "index": "", "length": "", "signal": ""}, "stocks"),
({"data": "", "index": "date", "length": "15", "signal": "2"}, "crypto"),
],
)
@pytest.mark.integration
def test_ta_fisher(params, obb):
def test_ta_fisher(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.fisher(**params)
assert result
@@ -154,31 +167,34 @@ def test_ta_fisher(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"fast": "",
"slow": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"fast": "5",
"slow": "15",
"offset": "2",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_adosc(params, obb):
def test_ta_adosc(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.adosc(**params)
assert result
@@ -187,35 +203,38 @@ def test_ta_adosc(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "",
"index": "",
"length": "",
"std": "",
"mamode": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"index": "date",
"length": "55",
"std": "3",
"mamode": "wma",
"offset": "1",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_bbands(params, obb):
def test_ta_bbands(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.bbands(**params)
assert result
@@ -224,31 +243,34 @@ def test_ta_bbands(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "",
"index": "",
"length": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"index": "date",
"length": "55",
"offset": "5",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_zlma(params, obb):
def test_ta_zlma(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.zlma(**params)
assert result
@@ -257,22 +279,24 @@ def test_ta_zlma(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}),
({"data": "", "index": "", "length": "", "scalar": ""}, "stocks"),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"length": "30",
"scalar": "110",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_aroon(params, obb):
def test_ta_aroon(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.aroon(**params)
assert result
@@ -281,31 +305,34 @@ def test_ta_aroon(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "",
"index": "",
"length": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"index": "date",
"length": "55",
"offset": "2",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_sma(params, obb):
def test_ta_sma(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.sma(**params)
assert result
@@ -314,33 +341,36 @@ def test_ta_sma(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"target": "",
"show_all": "",
"asint": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"target": "high",
"show_all": "true",
"asint": "true",
"offset": "5",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_demark(params, obb):
def test_ta_demark(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.demark(**params)
assert result
@@ -349,15 +379,16 @@ def test_ta_demark(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "index": "", "anchor": "", "offset": ""}),
({"data": get_crypto_data(), "index": "date", "anchor": "W", "offset": "5"}),
({"data": "", "index": "", "anchor": "", "offset": ""}, "stocks"),
({"data": "", "index": "date", "anchor": "W", "offset": "5"}, "crypto"),
],
)
@pytest.mark.integration
def test_ta_vwap(params, obb):
def test_ta_vwap(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.vwap(**params)
assert result
@@ -366,33 +397,36 @@ def test_ta_vwap(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "",
"index": "",
"fast": "",
"slow": "",
"signal": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"index": "date",
"fast": "10",
"slow": "30",
"signal": "10",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_macd(params, obb):
def test_ta_macd(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.macd(**params)
assert result
@@ -401,31 +435,34 @@ def test_ta_macd(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "",
"index": "",
"length": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"index": "date",
"length": "55",
"offset": "2",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_hma(params, obb):
def test_ta_hma(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.hma(**params)
assert result
@@ -434,31 +471,34 @@ def test_ta_hma(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"lower_length": "",
"upper_length": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"lower_length": "30",
"upper_length": "40",
"offset": "5",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_donchian(params, obb):
def test_ta_donchian(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.donchian(**params)
assert result
@@ -467,35 +507,38 @@ def test_ta_donchian(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"conversion": "",
"base": "",
"lagging": "",
"offset": "",
"lookahead": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"conversion": "10",
"base": "30",
"lagging": "50",
"offset": "30",
"lookahead": "true",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_ichimoku(params, obb):
def test_ta_ichimoku(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.ichimoku(**params)
assert result
@@ -504,22 +547,24 @@ def test_ta_ichimoku(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "index": "", "target": "", "period": ""}),
({"data": "", "index": "", "target": "", "period": ""}, "stocks"),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"target": "close",
"period": "95",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_clenow(params, obb):
def test_ta_clenow(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.clenow(**params)
assert result
@@ -528,31 +573,34 @@ def test_ta_clenow(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"length": "",
"scalar": "",
"drift": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"length": "60",
"scalar": "90.0",
"drift": "2",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_adx(params, obb):
def test_ta_adx(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.adx(**params)
assert result
@@ -561,31 +609,34 @@ def test_ta_adx(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "",
"index": "",
"length": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"index": "date",
"length": "60",
"offset": "10",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_wma(params, obb):
def test_ta_wma(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.wma(**params)
assert result
@@ -594,22 +645,24 @@ def test_ta_wma(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "index": "", "length": "", "scalar": ""}),
({"data": "", "index": "", "length": "", "scalar": ""}, "stocks"),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"length": "16",
"scalar": "0.02",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_cci(params, obb):
def test_ta_cci(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.cci(**params)
assert result
@@ -618,33 +671,36 @@ def test_ta_cci(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "",
"index": "",
"length": "",
"scalar": "",
"drift": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"index": "date",
"length": "16",
"scalar": "90.0",
"drift": "2",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_rsi(params, obb):
def test_ta_rsi(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.rsi(**params)
assert result
@@ -653,31 +709,34 @@ def test_ta_rsi(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"fast_k_period": "",
"slow_d_period": "",
"slow_k_period": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"fast_k_period": "12",
"slow_d_period": "2",
"slow_k_period": "2",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_stoch(params, obb):
def test_ta_stoch(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.stoch(**params)
assert result
@@ -686,33 +745,36 @@ def test_ta_stoch(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"length": "",
"scalar": "",
"mamode": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"length": "22",
"scalar": "24",
"mamode": "sma",
"offset": "5",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_kc(params, obb):
def test_ta_kc(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.kc(**params)
assert result
@@ -721,15 +783,16 @@ def test_ta_kc(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
({"data": get_stocks_data(), "index": "", "length": ""}),
({"data": get_crypto_data(), "index": "date", "length": "20"}),
({"data": "", "index": "", "length": ""}, "stocks"),
({"data": "", "index": "date", "length": "20"}, "crypto"),
],
)
@pytest.mark.integration
def test_ta_cg(params, obb):
def test_ta_cg(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.cg(**params)
assert result
@@ -738,33 +801,36 @@ def test_ta_cg(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"index": "",
"lower_q": "",
"upper_q": "",
"model": "",
"is_crypto": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"index": "date",
"lower_q": "0.3",
"upper_q": "0.7",
"model": "Parkinson",
"is_crypto": "true",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_cones(params, obb):
def test_ta_cones(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.cones(**params)
assert result
@@ -773,31 +839,34 @@ def test_ta_cones(params, obb):
@pytest.mark.parametrize(
"params",
"params, data_type",
[
(
{
"data": get_stocks_data(),
"data": "",
"target": "close",
"index": "date",
"length": "",
"offset": "",
}
},
"stocks",
),
(
{
"data": get_crypto_data(),
"data": "",
"target": "high",
"index": "",
"length": "60",
"offset": "10",
}
},
"crypto",
),
],
)
@pytest.mark.integration
def test_ta_ema(params, obb):
def test_ta_ema(params, data_type, obb):
params = {p: v for p, v in params.items() if v}
params["data"] = get_data(data_type)
result = obb.ta.ema(**params)
assert result