import pytest from studio_shared.shared_strategy_models import ( StrategyParam, StrategyParamMetadata, ) from studio_shared.strategy_code_helper import ( extract_params_from_strategy_code, ) def test_extracting_strategy_params_1() -> None: # Metadata: label strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01, "enable_ticks": True } params_metadata = { "rsi_period": { "label": "RSI period" }, "sizer": { "label": "Sizer" }, "sizer_custom_value": { "label": "Sizer Value" }, "enable_ticks": { "value_type": "bool" }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text=None, value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text=None, value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text=None, value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="enable_ticks", default_value=True, metadata=StrategyParamMetadata( label=None, helper_text=None, value_type="bool", enum_values=None, display_if_param_has_value=None, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_2() -> None: # Metadata: helper_text strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01 } params_metadata = { "rsi_period": { "helper_text": "RSI period description" }, "sizer": { "helper_text": "Custom Sizer description" }, "sizer_custom_value": { "helper_text": "Sizer Value description" }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label=None, helper_text="RSI period description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label=None, helper_text="Custom Sizer description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label=None, helper_text="Sizer Value description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_3() -> None: # Metadata: label, helper_text strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01 } params_metadata = { "rsi_period": { "label": "RSI period", "helper_text": "RSI period description", }, "sizer": { "label": "Sizer", "helper_text": "Custom Sizer description", }, "sizer_custom_value": { "label": "Sizer Value", "helper_text": "Sizer Value description" }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_4() -> None: # Metadata: label, helper_text, display_if_param_has_value strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01 } params_metadata = { "rsi_period": { "label": "RSI period", "helper_text": "RSI period description", }, "sizer": { "label": "Sizer", "helper_text": "Custom Sizer description", }, "sizer_custom_value": { "label": "Sizer Value", "helper_text": "Sizer Value description", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type=None, enum_values=None, display_if_param_has_value={"sizer": ["CustomSizer"]}, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_5() -> None: # Metadata: label, helper_text, display_if_param_has_value, value_type strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01 } params_metadata = { "rsi_period": { "label": "RSI period", "helper_text": "RSI period description", "value_type": "int", }, "sizer": { "label": "Sizer", "helper_text": "Custom Sizer description", "value_type": "str", }, "sizer_custom_value": { "label": "Sizer Value", "helper_text": "Sizer Value description", "value_type": "float", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type="int", enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type="str", enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type="float", enum_values=None, display_if_param_has_value={"sizer": ["CustomSizer"]}, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_6() -> None: # Metadata: label, helper_text, display_if_param_has_value, value_type, enum_values strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01 } params_metadata = { "rsi_period": { "label": "RSI period", "helper_text": "RSI period description", "value_type": "int", }, "sizer": { "label": "Sizer", "helper_text": "Custom Sizer description", "value_type": "str", "enum_values": ["FixedLotSizer", "FixedCashSizer", "AssignedMarginPercentSizer", "CustomSizer"] }, "sizer_custom_value": { "label": "Sizer Value", "helper_text": "Sizer Value description", "value_type": "float", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type="int", enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type="str", enum_values=[ "FixedLotSizer", "FixedCashSizer", "AssignedMarginPercentSizer", "CustomSizer", ], display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type="float", enum_values=None, display_if_param_has_value={"sizer": ["CustomSizer"]}, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_7() -> None: # Metadata: label, helper_text, display_if_param_has_value, value_type, enum_values strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01 } params_metadata = { "rsi_period": { "label": "RSI period", "helper_text": "RSI period description", "value_type": "int", }, "sizer": { "label": "Sizer", "helper_text": "Custom Sizer description", "value_type": "str", "enum_values": ["FixedLotSizer", "FixedCashSizer"] }, "sizer_custom_value": { "label": "Sizer Value", "helper_text": "Sizer Value description", "value_type": "float", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type="int", enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type="str", enum_values=["FixedLotSizer", "FixedCashSizer"], display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type="float", enum_values=None, display_if_param_has_value={"sizer": ["CustomSizer"]}, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_8() -> None: # Use tuples in params # Metadata: label, helper_text, display_if_param_has_value, value_type, enum_values strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = ( ("rsi_period", 9), ("overbought_threshold", 70), ("oversold_threshold", 30), ("sizer", "CustomSizer"), ("sizer_custom_value", 0.01) ) params_metadata = { "rsi_period": { "label": "RSI period", "helper_text": "RSI period description", "value_type": "int", }, "sizer": { "label": "Sizer", "helper_text": "Custom Sizer description", "value_type": "str", "enum_values": ["FixedLotSizer", "FixedCashSizer"] }, "sizer_custom_value": { "label": "Sizer Value", "helper_text": "Sizer Value description", "value_type": "float", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type="int", enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type="str", enum_values=["FixedLotSizer", "FixedCashSizer"], display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type="float", enum_values=None, display_if_param_has_value={"sizer": ["CustomSizer"]}, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_9() -> None: # Use tuples in params and params_metadata # Metadata: label, helper_text, display_if_param_has_value, value_type, enum_values strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = ( ("rsi_period", 9), ("overbought_threshold", 70), ("oversold_threshold", 30), ("sizer", "CustomSizer"), ("sizer_custom_value", 0.01) ) params_metadata = ( ("rsi_period", { "label": "RSI period", "helper_text": "RSI period description", "value_type": "int", }), ("sizer", { "label": "Sizer", "helper_text": "Custom Sizer description", "value_type": "str", "enum_values": ["FixedLotSizer", "FixedCashSizer"] }), ("sizer_custom_value", { "label": "Sizer Value", "helper_text": "Sizer Value description", "value_type": "float", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }), ) def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type="int", enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type="str", enum_values=["FixedLotSizer", "FixedCashSizer"], display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type="float", enum_values=None, display_if_param_has_value={"sizer": ["CustomSizer"]}, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_10() -> None: # Use tuples containing lists in params and params_metadata # Metadata: label, helper_text, display_if_param_has_value, value_type, enum_values strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = ( ["rsi_period", 9], ["overbought_threshold", 70], ["oversold_threshold", 30], ["sizer", "CustomSizer"], ["sizer_custom_value", 0.01] ) params_metadata = ( ['rsi_period', { "label": "RSI period", "helper_text": "RSI period description", "value_type": "int", }], ['sizer', { "label": "Sizer", "helper_text": "Custom Sizer description", "value_type": "str", "enum_values": ["FixedLotSizer", "FixedCashSizer"] }], ['sizer_custom_value', { "label": "Sizer Value", "helper_text": "Sizer Value description", "value_type": "float", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }], ) def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type="int", enum_values=None, display_if_param_has_value=None, ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type="str", enum_values=["FixedLotSizer", "FixedCashSizer"], display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type="float", enum_values=None, display_if_param_has_value={"sizer": ["CustomSizer"]}, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_11() -> None: # no params strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params_metadata = { "rsi_period": { "label": "RSI period", "helper_text": "RSI period description", "value_type": "int", }, "sizer": { "label": "Sizer", "helper_text": "Custom Sizer description", "value_type": "str", "enum_values": ["FixedLotSizer", "FixedCashSizer"] }, "sizer_custom_value": { "label": "Sizer Value", "helper_text": "Sizer Value description", "value_type": "float", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_12() -> None: # no params or params_metadata strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_13() -> None: # Misspelled params and params_metadata strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): paramssss = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01 } params_metadataaaaa = { "rsi_period": { "label": "RSI period", "helper_text": "RSI period description", "value_type": "int", }, "sizer": { "label": "Sizer", "helper_text": "Custom Sizer description", "value_type": "str", "enum_values": ["FixedLotSizer", "FixedCashSizer"] }, "sizer_custom_value": { "label": "Sizer Value", "helper_text": "Sizer Value description", "value_type": "float", "display_if_param_has_value": {"sizer": ["CustomSizer"]} }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_14() -> None: # Invalid syntax on import strategy_code = """ importtt backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01, "enable_ticks": True } params_metadata = { "rsi_period": { "label": "RSI period" }, "sizer": { "label": "Sizer" }, "sizer_custom_value": { "label": "Sizer Value" }, "enable_ticks": { "value_type": "bool" }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ with pytest.raises(SyntaxError): extract_params_from_strategy_code(strategy_code) def test_extracting_strategy_params_15() -> None: # Invalid params datatype strategy_code = """ import backtrader as bt from datetime import datetime class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01, "some_datetime_param": datetime.now() } params_metadata = { "rsi_period": { "label": "RSI period" }, "sizer": { "label": "Sizer" }, "sizer_custom_value": { "label": "Sizer Value" } } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", ), ), StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_with_ignore_non_simple() -> None: # rsi_period, start_datetime, and session_start_end_datetime are ignored as they are not simple literals # the rest of the params are successfully extracted strategy_code = """ import backtrader as bt from datetime import datetime class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": [1, 2, 3], "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01, "enable_ticks": True, "start_datetime": datetime(2020, 1, 1), "session_start_end_datetime": (datetime(2020, 1, 1, 9, 30), datetime(2020, 1, 1, 16, 0)), } params_metadata = { "rsi_period": { "label": "RSI period" }, "sizer": { "label": "Sizer" }, "sizer_custom_value": { "label": "Sizer Value" }, "enable_ticks": { "value_type": "bool" }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam(param_name="overbought_threshold", default_value=70, metadata=None), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text=None, value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text=None, value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="enable_ticks", default_value=True, metadata=StrategyParamMetadata( label=None, helper_text=None, value_type="bool", enum_values=None, display_if_param_has_value=None, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_with_dict_kwargs_in_params() -> None: # dict(**params_dict) in params should raise ValueError because **kwargs is not supported strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): base_params = { "rsi_period": 9, "overbought_threshold": 70, } params = dict(**base_params) def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.overbought_threshold: self.buy() """ with pytest.raises(ValueError): extract_params_from_strategy_code(strategy_code) def test_extracting_strategy_params_with_dict_kwargs_in_params_metadata() -> None: # dict(**metadata_dict) in params_metadata should raise ValueError because **kwargs is not supported strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, } base_metadata = { "rsi_period": { "label": "RSI period" }, } params_metadata = dict(**base_metadata) def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.overbought_threshold: self.buy() """ with pytest.raises(ValueError): extract_params_from_strategy_code(strategy_code) def test_extracting_strategy_params_with_valid_dict_in_params() -> None: # dict() with positional key-value arguments in params should work strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = dict( rsi_period=9, overbought_threshold=70, oversold_threshold=30, sizer="CustomSizer", sizer_custom_value=0.01 ) params_metadata = { "rsi_period": { "label": "RSI period" }, "sizer": { "label": "Sizer" }, "sizer_custom_value": { "label": "Sizer Value" }, } def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text=None, value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="overbought_threshold", default_value=70, metadata=None, ), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text=None, value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text=None, value_type=None, enum_values=None, display_if_param_has_value=None, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params def test_extracting_strategy_params_with_valid_dict_in_params_metadata() -> None: # dict() with positional key-value arguments in params_metadata should work strategy_code = """ import backtrader as bt class RSIOversoldOverboughtStrategy(bt.Strategy): params = { "rsi_period": 9, "overbought_threshold": 70, "oversold_threshold": 30, "sizer": "CustomSizer", "sizer_custom_value": 0.01 } params_metadata = dict( rsi_period={ "label": "RSI period", "helper_text": "RSI period description" }, sizer={ "label": "Sizer", "helper_text": "Custom Sizer description" }, sizer_custom_value={ "label": "Sizer Value", "helper_text": "Sizer Value description" } ) def __init__(self): self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period) def next(self) -> None: if not self.position: if self.rsi < self.params.oversold_threshold: self.buy() elif self.rsi > self.params.overbought_threshold: self.close() """ expected_params: list[StrategyParam] = [ StrategyParam( param_name="rsi_period", default_value=9, metadata=StrategyParamMetadata( label="RSI period", helper_text="RSI period description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="overbought_threshold", default_value=70, metadata=None, ), StrategyParam( param_name="oversold_threshold", default_value=30, metadata=None, ), StrategyParam( param_name="sizer", default_value="CustomSizer", metadata=StrategyParamMetadata( label="Sizer", helper_text="Custom Sizer description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), StrategyParam( param_name="sizer_custom_value", default_value=0.01, metadata=StrategyParamMetadata( label="Sizer Value", helper_text="Sizer Value description", value_type=None, enum_values=None, display_if_param_has_value=None, ), ), ] extracted_params = extract_params_from_strategy_code(strategy_code) assert extracted_params == expected_params