Updating a custom indicator with Indicator data points (from another standard indicator).

I've been trying to build this for 72 hours, and i decided it is time to seek help 

Your code for creating a custom indicator based on another indicator seems correct. You've created a FastADX class that inherits from PythonIndicator, and within its Update method, you're updating the AverageDirectionalIndex and calculating the DX value. You're then storing these DX values in a deque with a maximum length equal to the period you want to average over. Once the deque is full, you're calculating the average of these DX values to get your FastADX value.

However, it's important to note that the AverageDirectionalIndex (ADX) in QuantConnect includes the Positive Directional Index (+DI) and Negative Directional Index (-DI), which are calculated over a specified period. In your case, you're initializing AverageDirectionalIndex with a period of 14, so the +DI and -DI values will be calculated over 14 periods. If you want to calculate them over a different period, you would need to adjust the period when initializing AverageDirectionalIndex.

Also, remember to call the IsReady property of your custom indicator in your algorithm to ensure it's ready before using its value.

Here are the relevant extracts that might help:

• Extract 1: This forum discussion explains how to manually update the ADX indicator using a TradeBar object, which might be useful if you need to update your custom indicator with specific data.
• Extract 2: This documentation page provides an overview of the ADX indicator in QuantConnect, including how to create and update it.
• Extract 3: This forum discussion shows how to create a custom indicator and register it for automatic updates, which might be useful for your FastADX indicator.

Remember, creating custom indicators can be complex, and it's important to thoroughly test your indicator to ensure it's calculating the values you expect.

This AI is not helping and don't understand the problem, anyone Human available for help ? 

I'm sorry to hear that you're having trouble. If you need further assistance, you can escalate your support ticket to a human on the Support Team. To do this, after submitting your ticket, click "No, I'd like a human response" when prompted by Mia, the AI assistant. You can also reach out to the QuantConnect team via email at support@quantconnect.com or through the community forum or Discord for additional help.

For more information, please refer to the QuantConnect Support Documentation.

# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from AlgorithmImports import *
from collections import deque

class CustomIndicatorAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2021,1,1)
        self.SetEndDate(2024,5,1)
        self.symbol = self.AddCrypto("BTCUSDT", Resolution.Daily).Symbol

        self.custom = Volatility_ADX('custom', 7, 14)
		
# To register an custom indicator for automatic update, it need to provide only one single 
# value (here the single one value is: fast_adx - slow_adx)

        self.RegisterIndicator(self.symbol, self.custom )

        self.SetWarmUp(50)

        self.PlotIndicator('ADX: Fast - Slow', self.custom)


    #def OnData(self, slice: Slice) -> None:

       # if self.IsWarmingUp:
           # return

        '''
        Munual Update, if applied remove 'self.RegisterIndicator(self.symbol, self.custom )'
        
        if slice.Bars.ContainsKey(self.symbol):
            bar = slice.Bars[self.symbol]
            self.custom.Update(bar)
        '''
      


# Compute the difference between a 7 and 14 average ADX (with the +DI and -DI computed on 14 # period basis in both case)

class Volatility_ADX(PythonIndicator):
    def __init__(self, name, fast_period, slow_period):
        super().__init__()
        self.Name = name
      
        self.Value = 0
        self.fastqueue = deque(maxlen=fast_period)
        self.slowqueue = deque(maxlen=slow_period)

        self.adx = AverageDirectionalIndex(14)

    # Update method is mandatory
    def Update(self, input):

        self.adx.Update(input)

        if self.adx.IsReady:
            DX = (100 * abs((self.adx.PositiveDirectionalIndex.Current.Value) - (self.adx.NegativeDirectionalIndex.Current.Value))) / ((self.adx.PositiveDirectionalIndex.Current.Value) + (self.adx.NegativeDirectionalIndex.Current.Value))

            self.fastqueue.appendleft(DX)
            self.slowqueue.appendleft(DX)
        
        slowcount = len(self.slowqueue)
        fastcount = len(self.fastqueue)

        if slowcount == self.slowqueue.maxlen:
            SlowValue = np.sum(self.slowqueue) / slowcount
            FastValue = np.sum(self.fastqueue) / fastcount
            

            self.Value = FastValue - SlowValue

        
          
    

Your code for creating a custom indicator Volatility_ADX that calculates the difference between a 7-period and 14-period ADX seems correct. You're correctly initializing the AverageDirectionalIndex with a period of 14, and in the Update method, you're updating the AverageDirectionalIndex and calculating the DX value. You're then storing these DX values in two deques with maximum lengths equal to the fast and slow periods you want to average over. Once both deques are full, you're calculating the averages of these DX values to get your fast and slow ADX values, and then calculating the difference between these to get your Volatility_ADX value.

However, there are a few things to note:

1. You're registering your custom indicator for automatic updates with self.RegisterIndicator(self.symbol, self.custom). This means that the Update method of your custom indicator will be called automatically whenever new data for your symbol is available. If you want to manually update your custom indicator instead, you can comment out this line and uncomment the code in the OnData method that manually updates the custom indicator.

2. You're setting a warm-up period with self.SetWarmUp(50). This means that your algorithm will not start trading until 50 days of data have been processed. This is to ensure that your indicators are ready before you start trading. However, since your slow ADX is calculated over a period of 14 days, you might want to consider reducing your warm-up period to 14 days.

3. You're plotting your custom indicator with self.PlotIndicator('ADX: Fast - Slow', self.custom). This will plot the value of your custom indicator on a chart in your backtest results. This can be useful for visualizing the behavior of your custom indicator over time.

Here is the relevant extract that might help:

• Extract 1: This forum discussion explains how to create a custom indicator in Python. It shows how to create a class with an Update method, which is what you've done in your Volatility_ADX class.

Remember, creating custom indicators can be complex, and it's important to thoroughly test your indicator to ensure it's calculating the values you expect.

After spending many hours working on this problem, I've finally found a solution. The code I'm sharing is the very first template designed to calculate a custom indicator using a pre-existing indicator as a base.

I hope sharing this will save someone else the six full days of hard work and effort I put into solving it myself :))

# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from AlgorithmImports import *
from collections import deque

class CustomIndicatorAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2021,1,1)
        self.SetEndDate(2024,5,1)
        self.symbol = self.AddCrypto("BTCUSDT", Resolution.Daily).Symbol

        self.custom = Volatility_ADX('custom', 7, 14)


# To register a custom indicator for automatic update, its output need to be a single value.
# Here the single value is the fast adx minus the slow adx.


        self.RegisterIndicator(self.symbol, self.custom )

        self.SetWarmUp(50)

        self.PlotIndicator('ADX: Fast - Slow', self.custom)


    #def OnData(self, slice: Slice) -> None:

       # if self.IsWarmingUp:
           # return

        # For manual update (remove the RegisterIndicator method)
        #if slice.Bars.ContainsKey(self.symbol):
            #bar = slice.Bars[self.symbol]
            #self.custom.Update(bar)
        
        # Manually update the custom indicator
        #self.custom.Update(data["SPY"].Bars)
       
       

        # The current value of self.sma is represented by self.sma.Current.Value
        #self.Plot("Slow ADX", "fast", self.custom.SlowValue)
        #self.Plot("Fast ADX", "fast", self.custom.FastValue)


class Volatility_ADX(PythonIndicator):
    def __init__(self, name, fast_period, slow_period):
        super().__init__()
        self.Name = name
      
        self.Value = 0
        self.fastqueue = deque(maxlen=fast_period)
        self.slowqueue = deque(maxlen=slow_period)

        self.adx = AverageDirectionalIndex(14)

    # Update method is mandatory
    def Update(self, input):

        self.adx.Update(input)

        if self.adx.IsReady:
            DX = (100 * abs((self.adx.PositiveDirectionalIndex.Current.Value) - (self.adx.NegativeDirectionalIndex.Current.Value))) / ((self.adx.PositiveDirectionalIndex.Current.Value) + (self.adx.NegativeDirectionalIndex.Current.Value))

            self.fastqueue.appendleft(DX)
            self.slowqueue.appendleft(DX)
        
        slowcount = len(self.slowqueue)
        fastcount = len(self.fastqueue)

        if slowcount == self.slowqueue.maxlen:
            SlowValue = np.sum(self.slowqueue) / slowcount
            FastValue = np.sum(self.fastqueue) / fastcount
            
            #The single value the indicator return: the difference between the fast and slow 						    
            self.Value = FastValue - SlowValue