364 lines
13 KiB
Python
364 lines
13 KiB
Python
import importlib.util
|
|
import os
|
|
import struct
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from contextlib import redirect_stderr
|
|
from io import StringIO
|
|
from pathlib import Path
|
|
from unittest import mock
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(ROOT))
|
|
sys.path.insert(0, str(ROOT / "src"))
|
|
|
|
from platforms.qlib_runner import (
|
|
QlibUnavailableError,
|
|
_main,
|
|
build_alpha158_lightgbm_task,
|
|
generate_portable_momentum_signal,
|
|
run_native_momentum_backtest,
|
|
)
|
|
from tools.build_qlib_tiny_fixture import build_default_fixture
|
|
|
|
|
|
class QlibFixtureTest(unittest.TestCase):
|
|
def test_standard_library_fixture_has_expected_bin_header(self):
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
report = build_default_fixture(Path(temp), days=40)
|
|
feature = Path(temp) / "features/sh600000/close.day.bin"
|
|
payload = feature.read_bytes()
|
|
values = struct.unpack("<" + "f" * (len(payload) // 4), payload)
|
|
self.assertEqual(values[0], 0.0)
|
|
self.assertEqual(len(values), 41)
|
|
self.assertEqual(report["calendar_count"], 40)
|
|
self.assertTrue((Path(temp) / "calendars/day.txt").is_file())
|
|
self.assertTrue((Path(temp) / "instruments/csi300.txt").is_file())
|
|
|
|
def test_alpha158_lightgbm_config_uses_stable_097_paths(self):
|
|
config = build_alpha158_lightgbm_task(
|
|
market="csi300",
|
|
benchmark="SH000300",
|
|
train=("2018-01-01", "2020-12-31"),
|
|
valid=("2021-01-01", "2021-12-31"),
|
|
test=("2022-01-01", "2022-12-31"),
|
|
)
|
|
self.assertEqual(
|
|
config["task"]["model"]["module_path"],
|
|
"qlib.contrib.model.gbdt",
|
|
)
|
|
self.assertEqual(
|
|
config["task"]["dataset"]["kwargs"]["handler"]["module_path"],
|
|
"qlib.contrib.data.handler",
|
|
)
|
|
self.assertEqual(
|
|
config["portfolio_analysis"]["executor"]["class"],
|
|
"SimulatorExecutor",
|
|
)
|
|
self.assertEqual(
|
|
config["portfolio_analysis"]["strategy"]["class"],
|
|
"TopkDropoutStrategy",
|
|
)
|
|
|
|
@unittest.skipUnless(
|
|
importlib.util.find_spec("qlib") is not None
|
|
and os.environ.get("QUANT60_RUN_QLIB_NATIVE_SMOKE") == "1",
|
|
"set QUANT60_RUN_QLIB_NATIVE_SMOKE=1 in a pyqlib 0.9.7 env",
|
|
)
|
|
def test_optional_native_momentum_smoke(self):
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
build_default_fixture(Path(temp), days=80)
|
|
result = run_native_momentum_backtest(
|
|
provider_uri=temp,
|
|
market="csi300",
|
|
benchmark="SH000300",
|
|
start_time="2024-02-01",
|
|
end_time="2024-04-19",
|
|
topk=1,
|
|
n_drop=1,
|
|
)
|
|
self.assertGreater(len(result["signal"]), 0)
|
|
|
|
def test_missing_provider_fails_before_optional_import(self):
|
|
with self.assertRaises(FileNotFoundError):
|
|
run_native_momentum_backtest(
|
|
provider_uri="/definitely/missing/quant60-provider",
|
|
market="csi300",
|
|
benchmark="SH000300",
|
|
start_time="2024-01-01",
|
|
end_time="2024-02-01",
|
|
)
|
|
|
|
@unittest.skipUnless(
|
|
importlib.util.find_spec("pandas") is not None,
|
|
"pandas is optional outside the Qlib environment",
|
|
)
|
|
def test_weekly_signal_uses_true_first_provider_session(self):
|
|
import pandas
|
|
|
|
dates = pandas.bdate_range("2024-01-02", periods=20)
|
|
index = pandas.MultiIndex.from_product(
|
|
[["SH600000"], dates],
|
|
names=["instrument", "datetime"],
|
|
)
|
|
frame = pandas.DataFrame(
|
|
{"$close": [10.0 + index * 0.1 for index in range(len(dates))]},
|
|
index=index,
|
|
)
|
|
|
|
class FakeD:
|
|
@staticmethod
|
|
def features(*args, **kwargs):
|
|
del args, kwargs
|
|
return frame
|
|
|
|
signal = generate_portable_momentum_signal(
|
|
FakeD,
|
|
["SH600000"],
|
|
start_time="2024-01-02",
|
|
end_time="2024-01-31",
|
|
feature_start_time="2024-01-02",
|
|
lookback=2,
|
|
rebalance="weekly",
|
|
)
|
|
selected_dates = list(
|
|
signal.index.get_level_values("datetime").unique()
|
|
)
|
|
# Warm-up finishes mid-week, so that partial week is skipped. Every
|
|
# emitted date thereafter is the actual first provider session.
|
|
self.assertNotIn(pandas.Timestamp("2024-01-04"), selected_dates)
|
|
for selected in selected_dates:
|
|
week_dates = [
|
|
value
|
|
for value in dates
|
|
if value.to_period("W") == selected.to_period("W")
|
|
]
|
|
self.assertEqual(selected, min(week_dates))
|
|
|
|
|
|
class QlibCliTest(unittest.TestCase):
|
|
def test_legacy_momentum_cli_remains_default_and_writes_json(self):
|
|
fake_result = {
|
|
"qlib_version": "0.9.7",
|
|
"signal": [0.1, 0.2],
|
|
"portfolio_metrics": {"1day": object()},
|
|
"clock_contract": "test-clock",
|
|
"strategy_fidelity": "signal-only",
|
|
"a_share_rule_fidelity": "approximation",
|
|
}
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
output = Path(temp) / "nested" / "summary.json"
|
|
with mock.patch(
|
|
"platforms.qlib_runner.run_native_momentum_backtest",
|
|
return_value=fake_result,
|
|
) as runner, mock.patch("builtins.print") as printer:
|
|
status = _main(
|
|
[
|
|
"--provider-uri",
|
|
temp,
|
|
"--start",
|
|
"2024-01-02",
|
|
"--end",
|
|
"2024-03-29",
|
|
"--feature-start",
|
|
"2023-12-01",
|
|
"--lookback",
|
|
"10",
|
|
"--skip",
|
|
"2",
|
|
"--topk",
|
|
"20",
|
|
"--n-drop",
|
|
"3",
|
|
"--result-json",
|
|
str(output),
|
|
]
|
|
)
|
|
self.assertEqual(status, 0)
|
|
runner.assert_called_once_with(
|
|
provider_uri=temp,
|
|
market="csi300",
|
|
benchmark="SH000300",
|
|
start_time="2024-01-02",
|
|
end_time="2024-03-29",
|
|
feature_start_time="2023-12-01",
|
|
lookback=10,
|
|
skip=2,
|
|
topk=20,
|
|
n_drop=3,
|
|
rebalance="weekly",
|
|
)
|
|
payload = __import__("json").loads(output.read_text(encoding="utf-8"))
|
|
self.assertEqual(payload["workflow"], "momentum")
|
|
self.assertEqual(payload["signal_rows"], 2)
|
|
self.assertEqual(payload["portfolio_frequencies"], ["1day"])
|
|
self.assertIn('"workflow": "momentum"', printer.call_args.args[0])
|
|
|
|
def test_alpha158_cli_dispatches_with_validated_segments(self):
|
|
fake_result = {
|
|
"qlib_version": "0.9.7",
|
|
"experiment_name": "quant-os-test",
|
|
"recorder_id": "rec-123",
|
|
}
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
with mock.patch(
|
|
"platforms.qlib_runner.run_alpha158_lightgbm_workflow",
|
|
return_value=fake_result,
|
|
) as runner, mock.patch("builtins.print"):
|
|
status = _main(
|
|
[
|
|
"--workflow",
|
|
"alpha158",
|
|
"--provider-uri",
|
|
temp,
|
|
"--market",
|
|
"csi500",
|
|
"--benchmark",
|
|
"SH000905",
|
|
"--train-start",
|
|
"2018-01-01",
|
|
"--train-end",
|
|
"2020-12-31",
|
|
"--valid-start",
|
|
"2021-01-01",
|
|
"--valid-end",
|
|
"2021-12-31",
|
|
"--test-start",
|
|
"2022-01-01",
|
|
"--test-end",
|
|
"2022-12-31",
|
|
"--experiment-name",
|
|
"quant-os-test",
|
|
]
|
|
)
|
|
self.assertEqual(status, 0)
|
|
runner.assert_called_once_with(
|
|
provider_uri=temp,
|
|
market="csi500",
|
|
benchmark="SH000905",
|
|
train=("2018-01-01", "2020-12-31"),
|
|
valid=("2021-01-01", "2021-12-31"),
|
|
test=("2022-01-01", "2022-12-31"),
|
|
experiment_name="quant-os-test",
|
|
topk=50,
|
|
n_drop=5,
|
|
)
|
|
|
|
def test_alpha158_cli_rejects_missing_or_overlapping_segments(self):
|
|
base = [
|
|
"--workflow",
|
|
"alpha158",
|
|
"--provider-uri",
|
|
"/provider",
|
|
"--train-start",
|
|
"2018-01-01",
|
|
"--train-end",
|
|
"2020-12-31",
|
|
"--valid-start",
|
|
"2020-12-31",
|
|
"--valid-end",
|
|
"2021-12-31",
|
|
"--test-start",
|
|
"2022-01-01",
|
|
"--test-end",
|
|
"2022-12-31",
|
|
]
|
|
with mock.patch(
|
|
"platforms.qlib_runner.run_alpha158_lightgbm_workflow"
|
|
) as runner, redirect_stderr(StringIO()):
|
|
with self.assertRaises(SystemExit) as overlap:
|
|
_main(base)
|
|
with self.assertRaises(SystemExit) as missing:
|
|
_main(base[:-2])
|
|
self.assertEqual(overlap.exception.code, 2)
|
|
self.assertEqual(missing.exception.code, 2)
|
|
runner.assert_not_called()
|
|
|
|
def test_momentum_cli_rejects_invalid_dates_and_position_counts(self):
|
|
with mock.patch(
|
|
"platforms.qlib_runner.run_native_momentum_backtest"
|
|
) as runner, redirect_stderr(StringIO()):
|
|
with self.assertRaises(SystemExit) as dates:
|
|
_main(
|
|
[
|
|
"--provider-uri",
|
|
"/provider",
|
|
"--start",
|
|
"2024-02-01",
|
|
"--end",
|
|
"2024-01-01",
|
|
]
|
|
)
|
|
with self.assertRaises(SystemExit) as counts:
|
|
_main(
|
|
[
|
|
"--provider-uri",
|
|
"/provider",
|
|
"--start",
|
|
"2024-01-01",
|
|
"--end",
|
|
"2024-02-01",
|
|
"--topk",
|
|
"2",
|
|
"--n-drop",
|
|
"3",
|
|
]
|
|
)
|
|
self.assertEqual(dates.exception.code, 2)
|
|
self.assertEqual(counts.exception.code, 2)
|
|
runner.assert_not_called()
|
|
|
|
def test_cli_rejects_date_arguments_from_the_other_workflow(self):
|
|
with mock.patch(
|
|
"platforms.qlib_runner.run_native_momentum_backtest"
|
|
) as momentum_runner, redirect_stderr(StringIO()):
|
|
with self.assertRaises(SystemExit) as momentum:
|
|
_main(
|
|
[
|
|
"--provider-uri",
|
|
"/provider",
|
|
"--start",
|
|
"2024-01-01",
|
|
"--end",
|
|
"2024-02-01",
|
|
"--train-start",
|
|
"2020-01-01",
|
|
]
|
|
)
|
|
with mock.patch(
|
|
"platforms.qlib_runner.run_alpha158_lightgbm_workflow"
|
|
) as alpha_runner, redirect_stderr(StringIO()):
|
|
with self.assertRaises(SystemExit) as alpha:
|
|
_main(
|
|
[
|
|
"--workflow",
|
|
"alpha158",
|
|
"--provider-uri",
|
|
"/provider",
|
|
"--start",
|
|
"2022-01-01",
|
|
"--train-start",
|
|
"2018-01-01",
|
|
"--train-end",
|
|
"2020-12-31",
|
|
"--valid-start",
|
|
"2021-01-01",
|
|
"--valid-end",
|
|
"2021-12-31",
|
|
"--test-start",
|
|
"2022-01-01",
|
|
"--test-end",
|
|
"2022-12-31",
|
|
]
|
|
)
|
|
self.assertEqual(momentum.exception.code, 2)
|
|
self.assertEqual(alpha.exception.code, 2)
|
|
momentum_runner.assert_not_called()
|
|
alpha_runner.assert_not_called()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|