| Overall Statistics |
|
Total Orders 5721 Average Win 0.49% Average Loss -0.27% Compounding Annual Return 22.905% Drawdown 9.200% Expectancy 0.276 Start Equity 100000 End Equity 726129.37 Net Profit 626.129% Sharpe Ratio 1.542 Sortino Ratio 1.735 Probabilistic Sharpe Ratio 95.884% Loss Rate 55% Win Rate 45% Profit-Loss Ratio 1.83 Alpha 0.127 Beta 0.332 Annual Standard Deviation 0.103 Annual Variance 0.011 Information Ratio 0.472 Tracking Error 0.134 Treynor Ratio 0.479 Total Fees $0.00 Estimated Strategy Capacity $79000000.00 Lowest Capacity Asset QQQ RIWIV7K5Z9LX Portfolio Turnover 126.99% |
'''
1. Iteration
Nochmal großen Dank, das war wieder extrem hilfreich und gut strukturiert! Beim einen oder andere Code Schnipsel wäre es hilfreich, wenn wir den nochmal durchgehen und ich Kommentare ergänze.
2. Iteration - grünes Licht für diese Punkte:
Entry-Logik
--------------
Hier die Punkte vom letzten Mal.
Zur Re-Entry nur nach mindestens x Minuten - ist aus meienr Sicht doch nicht nötig, da man es über die Toleranzen steuern kann.
Task
------
Entry nur zwischen Start- und Endzeit - bitte die Ende-Zeit noch in config.json übernehmen und mir erklären wie das geht ;)
Entry-Modularisierung der Daten der Vortage
-------------------------------------------
Modularisierung
Task (ca. 2 h)
----------------
Bitte eine Logik ergänzen, mit der ich Filter anlegen kann, auf die ich über einen Integer Parameter abprüfen kann. Dazu habe ich mal meine GlobalSignals class beigefügt,
da ist eine Logik mit einem Dictionary drin welche True oder False wiedergibt. Du kannst gern aber auch was Schlankeres nehmen. Siehe im Code:
# Arthur, das sind Filter, die man immer wieder benutzen kann - wie kann man das modularisieren, zB mit einer Logik ähnlich wie in den Global Signals?
Task (ca. 2 h)
-----------------
Bitte einen Zugriff auf folgende Datenpunkte verfügbar machen. Idealerweise in einem in wiederverwendbaren Moduloder oder auch einem Monster-Indikator (es Security spezifische Datenpunkte).
EMA(close, daily, n days)
EMA(close, 4 Stunden, n perioden)
EMA(volume, daily, n days)
ATR(daily, n days)
Properties value_area_high und value_area_low aus dem Volume Profile des Vortages (https://www.quantconnect.com/docs/v2/writing-algorithms/indicators/supported-indicators/volume-profile)
Pre-Market High und Low. Dazu musst Du wohl auf extended Market Hours umswitchen.
O, H, L, C der letzten 5 Sessions, gern indiziert zB closeday[0] ist der Close von gestern. Würde zB diese Logik passen oder hast Du eine bessere idee?
self.close = self.algorithm.SMA(self.symbol, 1)
self.high = self.algorithm.MAX(self.symbol, 1)
self.low = self.algorithm.MIN(self.symbol, 1)
self.close.Window.Size = 5
self.high.Window.Size = 5
self.low.Window.Size = 5
Exit-Logik
------------
Hier vom letzten Mal.
Task (ca. 1.5 h)
--------------------
Indicator: Bitte die Toleranzen auf x * ATR,daily ausbauen
Architecture: Bitte ein Modul ergänzen, in dem ich dann verschiedene Exit-Kriterien ergänzen kann. Siehe im Code:
# Arthur, das ist nur exemplarisch - wie kann man die SL Logic modularisieren, zB einen Indicator?
PCM & Execution
----------------------
Da Du das EqualWeighting PCM genutzt hattest, habe ich mal das MultAlpha PCM eingebaut, denn es setzt auch auf dem EqualWeighting PCM auf. Die Ergebnisse sind identisch.
Ich bin mit der Modularisierung eigentlich soweit zufrieden.
Tasks (ca. 1.5 h)
------------------------
OnData: Geht das auch ohne OnData oder wie kann man das besser aufrufen? Kannst Du hier ggf. ein Code Beispiel machen oder es direkt umsetzen?
Vola Sizing: Könntest Du bitte die Volatiltiy (den ATR daily?) verfgbar machen? Dann könnte ich das nutzen, um 'switchable' ein Volatility Sizing einzubauen.
Kannst Du bitte zB im Security Init noch einen Leverage Factor hinterlegen? Im PCM habe ich folgenden Code:
adjusted_quantity = x.Quantity * algorithm.Securities[x.Symbol].Leverage * long_short_factor
GlobalSignals
------------------
Gerne können wir das im nächsten Call besprechen, hier suche ich auch nach Hilfe beim Modularisieren.
Tasks (ca. 1 h)
------------------------
Architecture: Wie kann man die globalen Variablen verfügbar machen ohne überall self.algorithm zu ergänzen? Kannst Du hier ggf. ein Code Beispiel machen oder es direkt umsetzen?
Indicator: Kannst Du bitte den SMA vom VIX schlank einbauen? Siehe Code:
self.vix_sma = 0 # Arthur, kannst Du dies hier bitte ergänzen? Ich hatte einen Mittelwert auf ein deque genutzt, geht aber sicher schlanker?
3. Iteration - Gerne können wir das im nächsten Call besprechen.
„Life Ready“ Themen - welche ToDo's siehst Du hier noch?
CFD Option
Weitere Alpha-Modelle
'''# region imports
from typing_extensions import Annotated
from AlgorithmImports import *
from pydantic import BaseModel, Field, field_serializer
import dateutil
from datetime import datetime, timedelta, timezone, date, time
# endregion
class AlgorithmConfig(BaseModel):
start_date: str | date
end_date: str | date
initial_capital: Annotated[int, Field(strict=False, gt=0)] = 100_000
directional_bias: int = +1 # -1=short only, +1=long only
tickers: str | list[str] = ["SPY"]
trading_start_time: time = time(hour=10, minute=0)
trading_end_time: time = time(hour=15, minute=59)
eod_exit: bool = False
costs_enabled: bool = True
leverage: float = 2.0
def model_post_init(self, __context) -> None:
if isinstance(self.start_date, str):
self.start_date = dateutil.parser.parse(self.start_date).date()
if isinstance(self.end_date, str):
self.end_date = dateutil.parser.parse(self.end_date).date()
if isinstance(self.tickers, str):
self.tickers = [*map(str.strip, self.tickers.split(','))]
@field_serializer('start_date', 'end_date')
def serialize_dates(self, dt: date, _info) -> str:
pass
def to_string(self):
self.model_dump_json()
# Define long and short multipliers which are used in the PCM. For testing, set to 1.
long_factor: float = 1.
short_factor: float = 1.
# Min order margin portfolio percentage to ignore bad orders and orders with small sizes in PCM. For testing, set to 0.
minimumOrderMarginPortfolioPercentage: float = 0. # 0.003 using $300 for a $100_000 portfolio
# Min order quantity change percentage to ignore bad orders and orders with small sizes. For testing, set to 0.
minimumOrderQuantityChangePercentage: float = 0.
# Max percentage of portfolio of one security per position. For testing, set to 1.
max_percentage_per_position: float = 1.
# Benchmark
myBenchmark: str = 'SPY'
# Global Signals
global_case_filter_condition: int = 1 # always True
# region imports
from AlgorithmImports import *
from analytics import SecurityAnalytics
# endregion
class CustomAlphaModel(AlphaModel):
def __init__(self):
self.name = self.__class__.__name__
self.securities = []
def update(self, algorithm: QCAlgorithm, data: Slice) -> list[Insight]:
insights = []
for security in self.securities:
insight = security.analytics.create_insight(algorithm, data)
if insight:
insights.append(insight)
return insights
def on_securities_changed(self, algorithm, changes):
for security in changes.added_securities:
if security.type is not SecurityType.EQUITY:
continue
if security in self.securities:
continue
security.analytics = SecurityAnalytics(algorithm, security)
self.securities.append(security)
for security in changes.removed_securities:
if security not in self.securities:
continue
self.securities.remove(security)
security.analytics.reset()
# region imports
from AlgorithmImports import *
from indicators import NoiseAreaIndicator, IntradayVWAP
from toolbox import TimeFrameHelper
# endregion
class SecurityAnalytics:
def __init__(self, algorithm: QCAlgorithm, security: Security) -> None:
self.algorithm = algorithm
self.security = security
self.symbol = security.symbol
tf_helper = TimeFrameHelper(security, Resolution.MINUTE)
self.insight = Insight.price(symbol=self.symbol, period=timedelta(1), direction=InsightDirection.FLAT)
# NoiseAreaIndicator
period = tf_helper.quarter
scaling_factor = 0.8 # reduces the noise area, as breakouts already happen for smaller noise areas than the average
gap_stretch_factor = 1.8 # increases the noise area asymmetrically to the gap side
#self.noise_area_exit_tol = -0.002 # currently unused
self.noise_area = NoiseAreaIndicator(tf_helper, period, scaling_factor, gap_stretch_factor)
algorithm.warm_up_indicator(security.symbol, self.noise_area, Resolution.MINUTE)
algorithm.register_indicator(security.symbol, self.noise_area, Resolution.MINUTE)
#---------------------------------
# Entry-Logik
# Arthur, das sind Prior Day Filter, die man immer wieder benutzen kann - wie kann man das modularisieren, zB mit einer Logik ähnlich wie in den Global Signals?
# Exclude extreme gaps
self.gap_min_long = -0.04
self.gap_max_short = +0.04
# VWAP
self.vwap_entry_tol = 0.0010 # Arthur, müsste ein ATR Faktor sein
self.vwap_exit_tol = -0.0005 # Arthur, müsste ein ATR Faktor sein. Vorschicht, ich habe die Logik der Vorzeichen verändert!
self.vwap = IntradayVWAP()
algorithm.warm_up_indicator(security.symbol, self.vwap, Resolution.MINUTE)
algorithm.register_indicator(security.symbol, self.vwap, Resolution.MINUTE)
# Regime Min, Max, MA
regime_max_period = 3
self.regime_max = Maximum(period=regime_max_period)
#algorithm.warm_up_indicator(security.symbol, self.regime_max, Resolution.DAILY, Field.CLOSE)
#algorithm.register_indicator(security.symbol, self.regime_max, Resolution.DAILY, Field.CLOSE)
#algorithm.warm_up_indicator(security.symbol, self.regime_max, Resolution.DAILY, Field.HIGH)
#algorithm.register_indicator(security.symbol, self.regime_max, Resolution.DAILY, Field.HIGH)
algorithm.warm_up_indicator(security.symbol, self.regime_max, Resolution.DAILY, Field.LOW)
algorithm.register_indicator(security.symbol, self.regime_max, Resolution.DAILY, Field.LOW)
#regime_min_period = 3
#self.regime_min = Maximum(period=regime_min_period)
#algorithm.warm_up_indicator(security.symbol, self.regime_min, Resolution.DAILY, Field.CLOSE)
#algorithm.register_indicator(security.symbol, self.regime_min, Resolution.DAILY, Field.CLOSE)
#algorithm.warm_up_indicator(security.symbol, self.regime_min, Resolution.DAILY, Field.HIGH)
#algorithm.register_indicator(security.symbol, self.regime_min, Resolution.DAILY, Field.HIGH)
#algorithm.warm_up_indicator(security.symbol, self.regime_min, Resolution.DAILY, Field.LOW)
#algorithm.register_indicator(security.symbol, self.regime_min, Resolution.DAILY, Field.LOW)
#regime_ma_period = 5
#self.regime_ma = SimpleMovingAverage(period=regime_ma_period)
#algorithm.warm_up_indicator(security.symbol, self.regime_ma, Resolution.DAILY, Field.CLOSE)
#algorithm.register_indicator(security.symbol, self.regime_ma, Resolution.DAILY, Field.CLOSE)
#---------------------------------
# Exit-Logik
# Arthur, das ist nur exemplarisch - wie kann man die SL Logic modularisieren, zB einen Indicator?
# Trailing EMA stop loss
trailing_ema_period = 60
self.trailing_ema_exit_tol = -0.005 # müsste ein ATR Faktor sein
self.trailing_ema = SimpleMovingAverage(period=trailing_ema_period)
algorithm.warm_up_indicator(security.symbol, self.trailing_ema, Resolution.MINUTE, Field.CLOSE)
algorithm.register_indicator(security.symbol, self.trailing_ema, Resolution.MINUTE, Field.CLOSE)
# Time SMA to avoid spikes to trigger stop loss
time_sma_period = 3
self.time_sma = SimpleMovingAverage(period=time_sma_period)
algorithm.warm_up_indicator(security.symbol, self.time_sma, Resolution.MINUTE, Field.CLOSE)
algorithm.register_indicator(security.symbol, self.time_sma, Resolution.MINUTE, Field.CLOSE)
# EoD MA to allow overnight holdings in case we are on the safe side of the moving average
eod_ma_period = 50
self.eod_ma = SimpleMovingAverage(period=eod_ma_period)
algorithm.warm_up_indicator(security.symbol, self.eod_ma, Resolution.DAILY, Field.CLOSE)
algorithm.register_indicator(security.symbol, self.eod_ma, Resolution.DAILY, Field.CLOSE)
#---------------------------------
def create_insight(self, algorithm: QCAlgorithm, data: Slice) -> Insight | None:
if self.noise_area.is_ready:
algorithm.plot("Noise Area", "Upper Bound", self.noise_area.upper_bound)
algorithm.plot("Noise Area", "Lower Bound", self.noise_area.lower_bound)
algorithm.plot("Noise Area", "Price", self.security.price)
if self.vwap.is_ready:
algorithm.plot("Noise Area", "VWAP", self.vwap.value)
if not self.can_emit_insight:
return
if self.insight.direction is not InsightDirection.FLAT:
# exit
if self.exit_conditions_met:
self.insight = Insight.price(symbol=self.symbol, period=timedelta(1), direction=InsightDirection.FLAT)
return self.insight
# exit-and-reverse
if not self.algorithm.config.eod_exit:
if self.insight.direction is InsightDirection.DOWN and self.long_entry_conditions_met:
self.insight = Insight.price(symbol=self.symbol, period=timedelta(1), direction=InsightDirection.UP)
return self.insight
if self.insight.direction is InsightDirection.UP and self.short_entry_conditions_met:
self.insight = Insight.price(symbol=self.symbol, period=timedelta(1), direction=InsightDirection.DOWN)
return self.insight
else:
if self.long_entry_conditions_met:
self.insight = Insight.price(symbol=self.symbol, period=timedelta(1), direction=InsightDirection.UP)
return self.insight
if self.short_entry_conditions_met:
self.insight = Insight.price(symbol=self.symbol, period=timedelta(1), direction=InsightDirection.DOWN)
return self.insight
return
@property
def long_entry_conditions_met(self) -> bool:
gap = (self.noise_area.day_open - self.noise_area.previous_day_close) / self.noise_area.previous_day_close if self.noise_area.previous_day_close != 0 else -1.
#---------------------------------
# Arthur, das sind Prior Day Filter, die man immer wieder benutzen kann - wie kann man das modularisieren, zB mit einer Logik ähnlich wie in den Global Signals?
prior_days_condition = (
gap > self.gap_min_long and
#self.security.price < self.regime_max.Current.Value and
#self.security.price < self.regime_ma.Current.Value and
#self.security.price < self.regime_min.Current.Value and
#self.security.price > self.regime_max.Current.Value and
#self.security.price > self.regime_ma.Current.Value and
#self.security.price > self.regime_min.Current.Value and
True)
#---------------------------------
current_day_condition = (
self.security.price > self.noise_area.upper_bound and
#self.time_sma.Current.Value > self.noise_area.upper_bound and
self.security.price > self.vwap.value * (1 + self.vwap_entry_tol) and
#self.time_sma.Current.Value > self.vwap.value * (1 + self.vwap_entry_tol) and
True)
exit_preventing_condition = (
self.security.price > self.trailing_ema.Current.Value and
#self.security.price > self.trailing_ema.Current.Value * (1 + self.trailing_ema_exit_tol) and
True)
# Arthur, wie kann ich hier auf den Case Filter zugreifen?
case_filter_condition = True
#case_filter_condition = self.algorithm.global_case_filter.check_condition(self.algorithm.config.global_case_filter_condition)
if prior_days_condition and current_day_condition and exit_preventing_condition and case_filter_condition and self.algorithm.config.directional_bias >= 0:
return True
return False
@property
def short_entry_conditions_met(self) -> bool:
gap = (self.noise_area.day_open - self.noise_area.previous_day_close) / self.noise_area.previous_day_close if self.noise_area.previous_day_close != 0 else +1.
prior_days_condition = (
gap < self.gap_max_short and
#self.security.price < self.regime_max.Current.Value and
#self.security.price < self.regime_ma.Current.Value and # gutes ergebnis
#self.security.price < self.regime_min.Current.Value and
self.security.price > self.regime_max.Current.Value and
#self.security.price > self.regime_ma.Current.Value and # gleichmässig
#self.security.price > self.regime_min.Current.Value and
True)
current_day_condition = (
self.security.price < self.noise_area.lower_bound and
#self.time_sma.Current.Value < self.noise_area.lower_bound and
self.security.price < self.vwap.value * (1 - self.vwap_entry_tol) and
#self.time_sma.Current.Value < self.vwap.value * (1 - self.vwap_entry_tol) and
True)
exit_preventing_condition = (
self.security.price < self.trailing_ema.Current.Value and
#self.security.price < self.trailing_ema.Current.Value * (1 - self.trailing_ema_exit_tol) and
True)
case_filter_condition = True
#case_filter_condition = self.algorithm.global_case_filter.check_condition(self.algorithm.config.global_case_filter_condition)
if prior_days_condition and current_day_condition and exit_preventing_condition and case_filter_condition and self.algorithm.config.directional_bias <= 0:
return True
return False
@property
def exit_conditions_met(self) -> bool:
if self.insight.direction is InsightDirection.UP:
exit_standard_condition = (
(self.security.price < self.trailing_ema.Current.Value * (1 + self.trailing_ema_exit_tol)) or
False)
exit_alpha_condition = (
#self.security.price < self.noise_area.upper_bound * (1 + self.noise_area_exit_tol) or
#self.security.price < self.vwap.value * (1 + self.vwap_exit_tol) or
(self.security.price < self.vwap.value * (1 + self.vwap_exit_tol) and self.time_sma.Current.Value < self.vwap.value * (1 + self.vwap_exit_tol)) or
False)
if exit_standard_condition or exit_alpha_condition:
return True
if self.insight.direction is InsightDirection.DOWN:
exit_standard_condition = (
(self.security.price > self.trailing_ema.Current.Value * (1 - self.trailing_ema_exit_tol)) or
False)
exit_alpha_condition = (
#self.security.price > self.noise_area.lower_bound * (1 - self.noise_area_exit_tol) or
#self.security.price > self.vwap.value * (1 - self.vwap_exit_tol) or
(self.security.price > self.vwap.value * (1 - self.vwap_exit_tol) and self.time_sma.Current.Value > self.vwap.value * (1 - self.vwap_exit_tol)) or
False)
if exit_standard_condition or exit_alpha_condition:
return True
if self.security.exchange.is_closing_soon(minutes_to_close=1):
exit_eod_condition = (
self.algorithm.config.eod_exit or
self.insight.direction is InsightDirection.UP and self.security.price < self.eod_ma.Current.Value or
self.insight.direction is InsightDirection.DOWN and self.security.price > self.eod_ma.Current.Value or
False)
if exit_eod_condition:
return True
return False
@property
def can_emit_insight(self) -> bool:
if not self.security.is_tradable:
return False
if not self.security.exchange.exchange_open:
return False
if not self.security.has_data:
return False
if self.algorithm.time.time() < self.algorithm.config.trading_start_time:
return False
if self.algorithm.time.time() >= self.algorithm.config.trading_end_time and self.insight.direction is InsightDirection.FLAT:
return False
if self.security.exchange.is_closing_soon(minutes_to_close=1) and self.insight.direction is InsightDirection.FLAT:
return False
return True
#region imports
from AlgorithmImports import *
#endregion
class GlobalCaseFilter:
"""
Applies a boolean filter based on the input variable using a dictionary of conditions.
Condition 0 returns always True.
Usage:
def initialize(algorithm):
global_case_filter = CaseFilter(algorithm)
result = global_case_filter.check_condition(3)
"""
def __init__(self, algorithm):
self.algorithm = algorithm
# Placeholder condition methods
def condition_1(self):
return True
def condition_2(self):
return False
def check_condition(self, input_var: int) -> bool:
conditions = {
# Direct boolean values
0: False, # always False as a benchmark and for up:True / down:not False
1: True, # always True as a benchmark and for up:True / down:not False
# Existing variables
2: self.algorithm.Vix_less_SMA1,
# Method references
98: self.condition_1,
99: self.condition_2,
}
# We can (a) call the condition method reference or (b) evaluate the direct boolean condition
if input_var in conditions:
condition = conditions[input_var]
return condition() if callable(condition) else condition
else:
return False
class GlobalSignals:
"""
Creates global indicators and manages their update.
Usage:
def initialize(algorithm):
global_signals = GlobalSignals(algorithm)
def OnData(algorithm, data: Slice):
algorithm.global_signals.OnData(data)
"""
def __init__(self, algorithm):
self.algorithm = algorithm
# vix
self.vix = algorithm.AddIndex("VIX").Symbol
self.vix_sma = 0 # Arthur, kannst Du dies hier bitte ergänzen? Ich hatte einen Mittelwert auf ein deque genutzt, geht aber sicher schlanker?
# make results available globally
self.algorithm.Vix_Value = 0
self.algorithm.Vix_less_SMA = False
def OnData(self, slice):
# vix
if slice.ContainsKey(self.vix):
self.algorithm.Vix_Value = slice[self.vix].Close
self.algorithm.Vix_less_SMA = self.algorithm.Vix_Value <= self.vix_sma
# region imports
from AlgorithmImports import *
from itertools import repeat
from toolbox import TimeFrameHelper
# endregion
class NoiseAreaIndicator(PythonIndicator):
def __init__(self, tf_helper: TimeFrameHelper, period=63, scaling_factor=1.0, gap_stretch_factor = 1.0):
self.time = datetime.min
self.value = 0
self.period = period # tf_helper.quarter
self.warm_up_period = int(tf_helper.day*self.period) + 1
self.count = 0
self.first_bar_of_day = TradeBar(time=self.time, symbol=None, open=0, high=0, low=0, close=0, volume=0)
self.day_open = 0
self.previous_close = 0
self.previous_day_open = 0
self.previous_day_close = 0
self.upper_bound_by_time = dict.fromkeys(range(1, tf_helper.day + 1), 0)
self.lower_bound_by_time = dict.fromkeys(range(1, tf_helper.day + 1), 0)
self.upper_bound = 0
self.lower_bound = 0
self.latest_time_for_reset = time(9,32)
self.sigma_by_time = dict(zip(range(1, tf_helper.day + 1), repeat(SimpleMovingAverage(self.period), tf_helper.day)))
self.scaling_factor = scaling_factor
self.gap_stretch_factor = gap_stretch_factor
def update(self, data: TradeBar) -> bool:
if self.first_bar_of_day.time.day != data.end_time.day:
if data.end_time.time() > self.latest_time_for_reset:
return
self.previous_day_open = self.day_open
self.previous_day_close = self.previous_close
self.first_bar_of_day = data
self.day_open = self.first_bar_of_day.open
minutes_elapsed = int((data.end_time - self.first_bar_of_day.time).total_seconds() // 60)
abs_move = abs(data.close / self.first_bar_of_day.open - 1)
self.sigma_by_time[minutes_elapsed].update(data.end_time, abs_move)
upper_bound_reference = lower_bound_reference = self.first_bar_of_day.open
if self.previous_day_close is not None:
#upper_bound_reference = max(upper_bound_reference, self.previous_day_close)
upper_bound_reference = upper_bound_reference + max(0, self.previous_day_close-upper_bound_reference) * self.gap_stretch_factor
#lower_bound_reference = min(lower_bound_reference, self.previous_day_close)
lower_bound_reference = lower_bound_reference - min(0, lower_bound_reference-self.previous_day_close) * self.gap_stretch_factor
self.upper_bound = upper_bound_reference * (1 + self.sigma_by_time[minutes_elapsed].current.value * self.scaling_factor) # scaling nur auf sigma angewandt
self.upper_bound_by_time[minutes_elapsed] = self.upper_bound
lower_bound_reference = self.first_bar_of_day.open
self.lower_bound = lower_bound_reference * (1 - self.sigma_by_time[minutes_elapsed].current.value / self.scaling_factor) # scaling nur auf sigma angewandt
self.lower_bound_by_time[minutes_elapsed] = self.lower_bound
self.previous_close = data.close
self.count += 1
return self.is_ready
@property
def is_ready(self) -> bool:
return self.count > self.warm_up_period
def reset(self):
self.time = datetime.min
self.value = 0
class IntradayVWAP(PythonIndicator):
def __init__(self, name='VWAP'):
self.name = name
self.value = 0
self.time = datetime.min
self.sum_of_volume = 0
self.sum_of_dollar_volume = 0
self.count = 0
self.warm_up_period = 1
def update(self, data: TradeBar) -> bool:
if data.is_fill_forward:
return self.is_ready
if data.end_time.day != self.time.day:
self.sum_of_volume = 0
self.sum_of_dollar_volume = 0
self.count = 0
avg_price = (data.high + data.low + data.close) / 3
self.sum_of_volume += data.volume
self.sum_of_dollar_volume += avg_price * data.volume
if self.sum_of_volume == 0:
self.value = data.value
return self.is_ready
self.value = self.sum_of_dollar_volume / self.sum_of_volume
self.time = data.end_time
self.count += 1
return self.is_ready
@property
def is_ready(self) -> bool:
return self.sum_of_volume > 0 and self.count >= 1
# region imports
from AlgorithmImports import *
from toolbox import read_config
from security_init import IbkrSecurityInitializer
from alpha import CustomAlphaModel
from global_signals import GlobalSignals, GlobalCaseFilter
from pcm_execution import MultiAlphaHelpers, MultiAlphaAveragingDirectionPCM, MultiAlphaMinQuantityChangeExecutionModel
# endregion
class ConcretumIntradayMomentumStrategy(QCAlgorithm):
def initialize(algorithm):
config = read_config(algorithm)
algorithm.set_start_date(config.start_date)
algorithm.set_end_date(config.end_date)
algorithm.set_cash(config.initial_capital)
algorithm.set_brokerage_model(BrokerageName.INTERACTIVE_BROKERS_BROKERAGE, AccountType.MARGIN)
algorithm.set_security_initializer(IbkrSecurityInitializer(algorithm, algorithm.brokerage_model, FuncSecuritySeeder(algorithm.get_last_known_price)))
algorithm.set_risk_free_interest_rate_model(ConstantRiskFreeRateInterestRateModel(0))
# Universe
for ticker in config.tickers:
security = algorithm.add_equity(ticker, resolution=Resolution.MINUTE, fill_forward=True, leverage=algorithm.config.leverage, extended_market_hours=False)
# Benchmark
algorithm.myBenchmark = algorithm.config.myBenchmark
algorithm.SetBenchmark(algorithm.myBenchmark)
# Alpha Models
algorithm.add_alpha(CustomAlphaModel())
#algorithm.set_portfolio_construction(EqualWeightingPortfolioConstructionModel(lambda t: None))
#algorithm.set_execution(ImmediateExecutionModel())
# Multi Alpha PCM and Execution
algorithm.ma_helpers = MultiAlphaHelpers(algorithm)
algorithm.set_portfolio_construction(MultiAlphaAveragingDirectionPCM(algorithm,
rebalance=Resolution.Daily,
portfolioBias=PortfolioBias.LongShort,
long_factor=algorithm.config.long_factor, short_factor=algorithm.config.short_factor,
use_multi_alpha_insights=True, use_direction_averaged_weighting=True,
max_percentage_per_position=algorithm.config.max_percentage_per_position))
algorithm.set_execution(MultiAlphaMinQuantityChangeExecutionModel(
algorithm.config.minimumOrderQuantityChangePercentage))
# Global Signals
algorithm.global_signals = GlobalSignals(algorithm)
algorithm.global_case_filter = GlobalCaseFilter(algorithm)
def OnData(algorithm, data: Slice):
algorithm.ma_helpers.OnData(data)
algorithm.global_signals.OnData(data)
# region imports
from AlgorithmImports import *
from collections import defaultdict
# endregion
#----------------------------------------------------------------------------------------
#
# Multi Alpha Model Helpers
#
class MultiAlphaHelpers:
"""
Provide OnData and configure the basic settings for MultiAlphaAveragingDirectionPCM and MinQuantityChangeImmediateExecutionModel
Usage:
def initialize(algorithm):
algorithm.ma_helpers = MultiAlphaHelpers(algorithm)
def OnData(algorithm, data: Slice):
algorithm.ma_helpers.OnData(data)
"""
def __init__(self, algorithm):
self.algorithm = algorithm
self.ApplyStandardSettings()
def ApplyStandardSettings(self):
## PCM
# Enable rebalances when the Alpha model emits insights or when insights expire in PCM. For testing, set to False.
self.algorithm.Settings.RebalancePortfolioOnInsightChanges = True # Default = True
# Enable rebalances when security changes occur in PCM. For testing, set to False.
self.algorithm.Settings.RebalancePortfolioOnSecurityChanges = True # Default = True
# Min order margin portfolio percentage to ignore bad orders and orders with small sizes in PCM. For testing, set to 0.
self.algorithm.Settings.MinimumOrderMarginPortfolioPercentage = 0.003 # Default = 0.001, better to use a min order margin of $300 for a $100_000 portfolio size
# Define long and short multipliers which are used in the PCM. For testing, set to 1.0.
self.algorithm.long_factor = 1.0
self.algorithm.short_factor = 1.0
## Execution
# Min order quantity change to ignore bad orders and orders with small sizes in EXECUTION. For testing, set to 0.
self.algorithm.minimumOrderQuantityChangePercentage = 0.10 # Custom minimum order quantity change percentage of at least 10% of the currently held quantity
def OnData(self, slice: Slice):
"""
Test data
# MLI: Forward stock split 2 for 1 on 23.10.2023
# ADXN: Reverse stock split 1 for 20 on 23.10.2023
# 2023-09-01 00:00:00 2023-09-01 00:00:00 OnSecuritiesChanged received a removal for WGOV R735QTJ8XC9X.
# 2023-09-01 00:00:00 2023-09-01 00:00:00 SymbolData disposed a WGOV R735QTJ8XC9X with 1.
TODO Delistings etc. in depth testing
https://www.quantconnect.com/docs/v2/writing-algorithms/securities/asset-classes/us-equity/corporate-actions
TODO If you have indicators in your algorithm, reset and warm-up your indicators with ScaledRaw data when splits occur so that the data in your indicators account for the price adjustments that the splits cause.
https://www.quantconnect.com/docs/v2/writing-algorithms/indicators/key-concepts#10-Reset-Indicators
For notification in live mode, please check out this doc for reference to implementation as the "# notification action" in the attached backtest. This information is provided by QuantConnect, and is still available even if you choose other brokerages such as IB, as long as you chose QuantConnect data feed which is only available on QuantConnect Cloud.
Alternatively, you can subscribe to the Security Master dataset, and use Lean-CLI to update the data every day to get the splits and dividents.
https://www.quantconnect.com/forum/discussion/12273/will-i-get-split-dividends-events-on-live-if-i-am-using-interactive-brokers-data-feed/p1
"""
## Stock splits
# TODO check if we have the first candle of the day + test if events come once a day or more often
if self.algorithm.Time.hour == 9 and self.algorithm.Time.minute == 31:
for kvp in slice.Splits:
symbol = kvp.Key
#self.algorithm.Debug(f'{self.algorithm.Time} OnData received a split event for {symbol}.')
"""
# Handle stock splits for all alpha models with a 'ResetAndWarmUpIndicators' method in their SymbolData
# TODO in life mode: refresh all indicators daily to ensure we have most recent historical data? Is a reco of Jared from 2017
for alphaModel in self.algorithm.instantiated_alpha_models:
if hasattr(alphaModel, 'symbol_data') and symbol in alphaModel.symbol_data and hasattr(alphaModel.symbol_data[symbol], 'ResetAndWarmUpIndicators'):
modelName = getattr(alphaModel, 'Name', type(alphaModel).__name__)
#self.algorithm.Debug(f'{self.algorithm.Time} OnData handled a split event for {symbol} in {modelName}.')
alphaModel.symbol_data[symbol].ResetAndWarmUpIndicators()
"""
## Dividends
# TODO check if we have the first candle of the day + test if events come once a day or more often
if self.algorithm.Time.hour == 9 and self.algorithm.Time.minute == 31:
for kvp in slice.Dividends:
symbol = kvp.Key
#self.algorithm.Debug(f'{self.algorithm.Time} OnData received a dividend event for {symbol}.')
#----------------------------------------------------------------------------------------
#
# Multi Alpha Averaging Direction PCM
#
class MultiAlphaAveragingDirectionPCM(PortfolioConstructionModel):
"""
This PCM is designed to combine active insights from multiple Alpha Models based on the 'insight.Direction' using two methods:
(1) Equal weighting of each insight
1 We allocate 100% equally weighted to each active insight
(2) Directional averaging of each insight per symbol
1 We allocate 100% equally weighted to each symbol
2 We multiply the symbol share with the average direction from all insights for a symbol (value from -1 .. +1)
For further processing, we then distribute this result to all active insights
Insight Requirements:
Active: Insight must not be expired
Latest Insight per Alpha Model: Insight used is the most recent insight from its Alpha Model for a given symbol
'insight.Direction': The direction property is used to caclulate the portfolio share
Effects of active insights from several Alpha Models for one symbol:
'insight.Direction' is long: Vote for a bullish portfolio weight. If we have 1 long insight, the weight will be 100%.
'insight.Direction' is short: Vote for a bearish portfolio weight. If we have 1 long and 1 short insight, the weight will be 0%.
'insight.Direction' is not active: Don't vote at all. If we have 2 long insights and a third Alpha Model does not vote, the weight will be 2/2 = 100%.
'insight.Direction' is flat: Vote for a neutral portfolio weight. If we have 2 long and 1 neutral insights, the weight will be 2/3 = 66.7%.
!!! Note: This means that insights must be emitted as long as the Alpha Model sees a certain direction, not just once for an entry!!!
Parameters and Switches:
'portfolioBias': Insight must align with the portfolio bias
'long_factor' and 'short_factor': To adjust the quantity in the portfolio
'use_multi_alpha_insights': Switch to activate the grouping of insights by symbol and apha model
'use_direction_averaged_weighting': Switch for (1) equal weighting or (2) directional averaging
'max_percentage_per_position': The resulting position size must be within the specified portfolio limits
Implementation
It overrides all common methods of the base class. Changes are made in the GetTargetInsights and the
DetermineTargetPercent methods as suggested in the QC documentation.
https://www.quantconnect.com/docs/v2/writing-algorithms/algorithm-framework/portfolio-construction/key-concepts
GetTargetInsights:
To combine the active insights differently, the GetTargetInsights returns all active insights.
DetermineTargetPercent:
Target weights are beeing derived based on the average direction of all active insights from all Alpha Models for a symbol.
Usage:
self.SetPortfolioConstruction(MultiAlphaAveragingDirectionPCM(self))
"""
def __init__(self, algorithm, rebalance=Resolution.Daily, portfolioBias=PortfolioBias.LongShort, long_factor=1., short_factor=0.6,
use_multi_alpha_insights=True, use_direction_averaged_weighting=True, max_percentage_per_position=0.1):
super().__init__()
self.algorithm = algorithm
self.portfolioBias = portfolioBias
self.use_multi_alpha_insights = use_multi_alpha_insights
self.use_direction_averaged_weighting = use_direction_averaged_weighting
# Define long and short multipliers
self.long_factor = long_factor
self.short_factor = short_factor
# Define max percentage of portfolio of one security per position
self.max_percentage_per_position = max_percentage_per_position
def CreateTargets(self, algorithm, insights):
"""
Generates portfolio targets based on active insights from multiple Alpha Models.
This method aggregates multiple insights per symbol into a single portfolio target, applying leverage
and specified long/short factors. The resulting target ensures that the portfolio aligns with the
combined directional insights provided by different Alpha Models while respecting a maximum
percentage allocation per position.
"""
## Get targets from insights using the base model
targets_per_insight = super().CreateTargets(algorithm, insights)
# Return, if no targets
if len(targets_per_insight) == 0:
return targets_per_insight # same as return []
## Aggregate several targets per symbol to only one target per symbol
# Note: Immediate Execution model fills a PortfolioTargetCollection dict(k=Symbol,v=PortfolioTarget) using AddRange, commented as "If a target for the same symbol already exists it will be overwritten."
# So we have to ensure only one target per symbol is returned here.
targets_per_symbol = defaultdict(int)
for x in targets_per_insight:
# Determine long_short_factor
long_short_factor = self.long_factor if x.Quantity > 0 else self.short_factor
# Apply leverage and the long_short_factor and aggregate
adjusted_quantity = x.Quantity * algorithm.Securities[x.Symbol].Leverage * long_short_factor
targets_per_symbol[x.Symbol] += adjusted_quantity
## Limit the quantity to the max quantity per security
# Create new PortfolioTargets with aggregated quantities
if not self.max_percentage_per_position:
# Create new PortfolioTargets without limited quantities
targets = [PortfolioTarget(symbol, quantity) for symbol, quantity in targets_per_symbol.items()]
else:
# Create new PortfolioTargets with quantities limited by max percentage
total_portfolio_value = algorithm.Portfolio.TotalPortfolioValue
max_value = total_portfolio_value * self.max_percentage_per_position
targets = [PortfolioTarget(symbol, 0) if algorithm.Securities[symbol].Price == 0 else PortfolioTarget(symbol, np.sign(quantity) * int(min(abs(quantity), max_value / algorithm.Securities[symbol].Price)))
for symbol, quantity in targets_per_symbol.items()]
return targets
def GetTargetInsights(self) -> List[Insight]:
"""
Gets the last generated active insight for each symbol
"""
# Get all insights from the algorithm that haven't expired yet, for each symbol that is still in the universe
activeInsights = self.algorithm.Insights.GetActiveInsights(self.algorithm.UtcTime)
if self.use_multi_alpha_insights:
## GetTargetInsights by symbol and model
# Group insights by symbol and apha model using a nested defaultdict keyed by symbol and then source model; value = latest insight
last_insights_per_symbol_model = defaultdict(lambda: defaultdict(lambda: None))
# Iterate over each active insight and store it, if the insight is more recent than the currently stored one for its symbol and source model
for insight in activeInsights:
if insight.CloseTimeUtc >= self.algorithm.UtcTime: # only consider insights that are not outdated
current_stored_insight = last_insights_per_symbol_model[insight.Symbol][insight.SourceModel]
# Check if we already have a stored insight for this symbol and model, and if the new one is more recent
if current_stored_insight is None or insight.GeneratedTimeUtc > current_stored_insight.GeneratedTimeUtc:
last_insights_per_symbol_model[insight.Symbol][insight.SourceModel] = insight
# Flatten the nested dictionary to get a list of the latest active insights from each model for each symbol
self.insights = [insight for symbol_insights in last_insights_per_symbol_model.values() for insight in symbol_insights.values()]
else:
## GetTargetInsights by symbol only
# Group insights by symbol and get the last generated insight for each symbol
last_insights_per_symbol = defaultdict(list)
for insight in activeInsights:
last_insights_per_symbol[insight.Symbol].append(insight)
# Select the last generated active insight for each symbol
self.insights = [sorted(insights, key=lambda x: x.GeneratedTimeUtc)[-1] for insights in last_insights_per_symbol.values()]
return self.insights
def DetermineTargetPercent(self, activeInsights: List[Insight]) -> Dict[Insight, float]:
"""
Determines the target percentage allocation for each active insight based on the selected weighting method.
The process considers various factors such as the portfolio bias, the direction of insights, and whether
direction averaging or equal weighting is applied. The final output is a dictionary mapping each active
insight to its corresponding portfolio target percentage.
Parameters:
activeInsights : List[Insight]
A list of active insights that have not expired and are generated by various Alpha Models.
Returns:
A dictionary where each key is an active insight and the value is the target portfolio percentage
allocated to that insight.
Implementation Notes:
The method calculates the percentage allocation for each insight considering the number of active insights and their
respective directions.
The resulting portfolio allocation respects the constraints imposed by the portfolio bias and maximum position size.
The portfolio target percentage can be positive (long), negative (short), or zero (flat), depending on the calculated
insights and the portfolio's overall strategy.
"""
# Define the threshold for the expiry date comparison (4 days)
expiry_threshold = timedelta(days=4)
if self.use_direction_averaged_weighting == False:
## 'Equal Weighting' of each insight
# Same as EqualWeighting https://github.com/QuantConnect/Lean/blob/master/Algorithm.Framework/Portfolio/EqualWeightingPortfolioConstructionModel.cs#L118
insights_count = sum(1 for insight in activeInsights if insight.Direction != InsightDirection.Flat and self.RespectPortfolioBias(insight)) # we count all insights
pct_by_insight = {insight: 1. / insights_count if insights_count > 0 else 0 for insight in activeInsights if self.RespectPortfolioBias(insight)} # we allocate 100% equally weighted to each insight
else:
## 'Direction Averaged Weighting' per source Alpha model of each insight
insights_count = 0
symbol_insight_count = defaultdict(int)
symbol_insight_dir_sum = defaultdict(int)
for insight in activeInsights:
insights_count += 1 # we count all insights
symbol_insight_count[insight.Symbol] += 1 # we count all insights per symbol
symbol_insight_dir_sum[insight.Symbol] += insight.Direction # we add up all insight directions per symbol
symbols_count = len(symbol_insight_count)
# Arthur, bitte hier Zugriff auf die Vola ermöglichen
# Step 1: we allocate 100% EQUALLY weighted to each symbol to get the symbol share using (1. / symbols_count)
# Step 2: we multiply the symbol share with the average direction of this symbol (value from -1 .. +1) using (direction_sum / symbol_insight_count)
# Step 3: as targetPercent is indexed by insight, we may have several insights per symbol and therefore need to distribute the result per symbol to each insight of this symbol using (1. / symbol_insight_count)
pct_by_symbol = {symbol: (1./symbols_count) * (direction_sum / symbol_insight_count[symbol]) * (1./symbol_insight_count[symbol])
if symbol_insight_count[symbol] > 0 else 0 for symbol, direction_sum in symbol_insight_dir_sum.items()}
# Fill the target percent dict with the calculated percents for each insight
targetPercent = {}
for insight in activeInsights:
if self.use_direction_averaged_weighting == False:
## 'Equal Weighting' of each insight
# We apply percents indexed by insight
percent = pct_by_insight.get(insight, 0)
targetPercent[insight] = percent
else:
## 'Direction Averaged Weighting' per source Alpha model of each insight
# We apply percents indexed by symbol
percent = pct_by_symbol.get(insight.Symbol, 0)
# We need to switch the sign of the weight, if the signs of insight direction and weight are not the same
if percent * insight.Direction < 0:
percent = -percent
# If the portfolio bias and the sign of the weight are not the same, we need to filter by neglecting the weight
# We do this 'late' in the process, so we use an adverse direction in the averaging differently than 'Flat', even if we never enter in that direction
# This has to be conceptionally balanced with the Alpha Models (a) only emitting insights in case of entry (b) constantly emitting insights also in case of flat
if self.portfolioBias != PortfolioBias.LongShort and percent * self.portfolioBias < 0:
percent = 0
targetPercent[insight] = percent
return targetPercent
#----------------------------------------------------------------------------------------
#
# Minimum Changed Quantity ExecutionModel
#
class MultiAlphaMinQuantityChangeExecutionModel(ExecutionModel):
"""
An execution model that immediately submits market orders to achieve the desired portfolio targets, if the change in quantity
is significant enough based on a specified threshold. This helps avoid executing insignificant trades.
Based on ImmediateExecutionModel, added:
AboveMinimumQuantityChange to check if the quantity alters the current holdings by at least minimumOrderQuantityChangePercentage of the currently held quantity
'minimumOrderQuantityChangePercentage': The minimum percentage change in quantity required to execute an order, relative to the currently held quantity
Usage:
self.SetExecution(MultiAlphaMinQuantityChangeExecutionModel(minimumOrderQuantityChangePercentage=0.10))
"""
def __init__(self, minimumOrderQuantityChangePercentage=0.10):
# Initializes a new instance of the ImmediateExecutionModel class
self.minimumOrderQuantityChangePercentage = minimumOrderQuantityChangePercentage
self.targetsCollection = PortfolioTargetCollection()
def Execute(self, algorithm, targets):
"""
Immediately submits orders for the specified portfolio targets
Implementation:
The method first adds the incoming targets to the internal `targetsCollection`.
It then iterates over the targets, checking if the quantity to be ordered meets both the minimum order margin
and the minimum quantity change criteria.
If both criteria are met, a market order is submitted for the target quantity.
After execution, fulfilled targets are removed from the collection.
"""
# for performance we check count value, OrderByMarginImpact and ClearFulfilled are expensive to call
self.targetsCollection.AddRange(targets)
if not self.targetsCollection.IsEmpty:
for target in self.targetsCollection.OrderByMarginImpact(algorithm):
security = algorithm.Securities[target.Symbol]
# calculate remaining quantity to be ordered
quantity = OrderSizing.GetUnorderedQuantity(algorithm, target, security)
if quantity != 0:
aboveMinimumPortfolio = BuyingPowerModelExtensions.AboveMinimumOrderMarginPortfolioPercentage(security.BuyingPowerModel, security, quantity, algorithm.Portfolio, algorithm.Settings.MinimumOrderMarginPortfolioPercentage)
aboveMinimumQuantityChange = self.AboveMinimumQuantityChange(security, quantity, algorithm, self.minimumOrderQuantityChangePercentage)
#if aboveMinimumPortfolio:
if aboveMinimumPortfolio and aboveMinimumQuantityChange:
algorithm.MarketOrder(security, quantity)
elif not PortfolioTarget.MinimumOrderMarginPercentageWarningSent:
# will trigger the warning if it has not already been sent
PortfolioTarget.MinimumOrderMarginPercentageWarningSent = False
self.targetsCollection.ClearFulfilled(algorithm)
def AboveMinimumQuantityChange(self, security, quantity, algorithm, minimumOrderQuantityChangePercentage=0.1):
"""
Returns
True, if the calculated percentage change in quantity is greater than or equal to the specified minimum percentage
False, if the quantity does not alter the current holdings by at least minimumOrderQuantityChangePercentage
"""
# Calculate the percentage change in quantity relative to current holdings
currentHoldings = security.Holdings.Quantity
if currentHoldings == 0:
# If there are no current holdings, any quantity is significant
return True
# Calculate the percentage change
percentage_change = abs(quantity) / abs(currentHoldings)
# Check if the change is above the minimum threshold
return percentage_change >= minimumOrderQuantityChangePercentage
# region imports
from AlgorithmImports import *
# endregion
class IbkrSecurityInitializer(BrokerageModelSecurityInitializer):
def __init__(self, algorithm: QCAlgorithm, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
self.algorithm = algorithm
super().__init__(brokerage_model, security_seeder)
def initialize(self, security: Security) -> None:
super().initialize(security)
security.set_shortable_provider(InteractiveBrokersShortableProvider())
if not self.algorithm.config.costs_enabled:
#security.set_slippage_model(NullSlippageModel())
#security.set_slippage_model(HalvedSpreadSlippageModel())
security.set_slippage_model(FullSpreadSlippageModel())
security.set_fee_model(ConstantFeeModel(0))
class HalvedSpreadSlippageModel:
def GetSlippageApproximation(self, asset: Security, order: Order) -> float:
slippage = 0
if order.type is OrderType.MARKET:
# Arthur, ich habe hier das Vorzeichen verändert, da ja durch Slippage die PnL schlechter werden sollte (sie wurde besser)
slippage = +0.5 * max(0, (asset.ask_price - asset.bid_price))
return slippage
class FullSpreadSlippageModel:
def GetSlippageApproximation(self, asset: Security, order: Order) -> float:
slippage = 0
if order.type is OrderType.MARKET:
slippage = +1.0 * max(0, (asset.ask_price - asset.bid_price))
return slippage
'''
class ZeroSlippageFillModel(FillModel):
def market_fill(self, security: Security, order: Order) -> OrderEvent:
fill = super().market_fill(security, order)
fill_price = security.bid_price if order.quantity > 0 else security.ask_price
fill.fill_price = fill_price
return fill
def combo_market_fill(self, order: Order, parameters: FillModelParameters) -> List[OrderEvent]:
fills = super().combo_market_fill(order, parameters)
for kvp, fill in zip(sorted(parameters.securities_for_orders, key=lambda x: x.Key.Id), fills):
_security = kvp.value
fill_Price = _security.bid_price if fill.fill_quantity > 0 else _security.ask_price
fill.fill_price = fill_price
return fills
def stop_market_fill(self, security: Security, order: StopMarketOrder) -> OrderEvent:
fill = super().stop_market_fill(security, order)
fill_price = security.bid_price if order.quantity > 0 else security.ask_price
fill.fill_price = fill_price
return fill
'''
# region imports
from AlgorithmImports import *
from pydantic import BaseModel, ConfigDict
from algo_config import AlgorithmConfig
# endregion
def read_config(algorithm: QCAlgorithm) -> AlgorithmConfig:
#params = {param.key.lower(): param.value for param in algorithm.get_parameters()}
# Arthur, wie kann ich denn das config.json bearbeiten?
params = {
'start_date': '2015-01-01',
'end_date': '2024-08-10',
'initial_capital': '100_000',
'tickers': ['SPY', 'QQQ'],
'trading_start_time': '09:45',
'costs_enabled': 'False'}
algo_config = AlgorithmConfig(**params)
algorithm.config = algo_config
QCAlgorithm.config = algo_config
return algo_config
class ExtendedBaseModel(BaseModel):
model_config = ConfigDict(arbitrary_types_allowed=True)
class TimeFrameHelper:
def __init__(self, security: Security, resolution: Resolution):
bars_per_day = max(1, security.exchange.hours.regular_market_duration.total_seconds() / Extensions.to_time_span(resolution).total_seconds())
self.year = int(round(bars_per_day * security.exchange.trading_days_per_year, 0))
self.quarter = int(round(self.year/4, 0))
self.month = int(round(self.year/12, 0))
self.week = int(round(self.year/52, 0))
self.day = int(round(bars_per_day, 0))