How to get symbol price in BrainSentimentIndicatorUniverse coarse filter ?

Yes, you can filter out symbols based on price during the Coarse Universe Selection. The CoarseFundamental object has a Price property that you can use for this purpose. Here is an example of how you can do this in Python:

def CoarseSelectionFunction(self, coarse):
    return [x.Symbol for x in coarse if x.Price > X]

In this example, coarse is a list of CoarseFundamental objects, and X is the price threshold you want to use for filtering. This function will return a list of symbols for securities that have a price greater than X.

You can find more information about this in the QuantConnect documentation.

Please note that the CoarseSelectionFunction is called once per day at midnight, and the coarse list it receives contains data from the previous day. Therefore, the prices you are filtering on are from the close of the previous trading day.

Sources:

• Coarse Universe Selection
• Forum Discussion: Filtering non-optionable securities in Universe Selection
• Forum Discussion: Universe Selection Based on Price History
• Forum Discussion: Porting a common pipeline from Quantopian to QuantConnect

Yes, I am aware of the fundamentals universe but how do I combine it with the BrainSentiment Universe in order to filter on both sentiment and price?

Cheers,

Andres

To combine the BrainSentimentIndicatorUniverse and the CoarseFundamental universe, you can use the concept of "chained universes". This allows you to fetch fundamental and alternative data on a specific subset of assets.

First, you would define your BrainSentimentIndicatorUniverse to filter based on sentiment. Then, you would chain this with the CoarseFundamental universe to further filter based on price.

Here is an example of how you can do this in Python:

class MyAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.UniverseSettings.Resolution = Resolution.Daily
        self.SetStartDate(2016, 1, 1)
        self.SetEndDate(2018, 1, 1)
        self.SetCash(100000)

        self.AddUniverse(self.CoarseSelectionFunction)
        self.AddUniverseSelection(BrainSentimentIndicatorUniverse(self.universe_selection))

    def universe_selection(self, alt_coarse: List[BrainSentimentIndicatorUniverse]) -> List[Symbol]:
        return [d.symbol for d in alt_coarse if d.total_article_mentions7_days > 0 and d.sentiment7_days]

    def CoarseSelectionFunction(self, coarse):
        return [x.Symbol for x in coarse if x.Price > X]

In this example, universe_selection is the function that filters the BrainSentimentIndicatorUniverse based on sentiment, and CoarseSelectionFunction is the function that filters the CoarseFundamental universe based on price.

Please note that the CoarseSelectionFunction is called once per day at midnight, and the coarse list it receives contains data from the previous day. Therefore, the prices you are filtering on are from the close of the previous trading day.

Sources:

• Chained Universes
• Brain Sentiment Indicator Universe
• Coarse Universe Selection

Hi Mia,

Based on your suggestion and the Chanied Universe and Alternative Data (https://www.quantconnect.com/docs/v2/writing-algorithms/universes/equity/chained-universes#00-Introduction), I've been working on the code but I am getting the following error message when I try to return the join of the two filters:

'WellDressedSkyBlueSardine' object has no attribute 'fundamental'
  at universe_selection
    return list (set(self.fundamental) & set(sortedby30daySentiment))
                     ^^^^^^^^^^^^^^^^
 in main.py: line 36

Could you please take a look at the attached code to see why this does not work?

BTW, I also tried doing the BrainSentiment filter first but got the error message when I tried to sort: 

'<' not supported between instances of 'NoneType' and 'float'
  at universe_selection
    sortedby30daySentiment = sorted (alt_coarse, key=lambda x: x.sentiment_30_days, reverse=True)
                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 in main.py: line 33

Based on the error messages you provided, it seems like there are two issues with your code:

1. 'WellDressedSkyBlueSardine' object has no attribute 'fundamental': This error suggests that you are trying to access a 'fundamental' attribute of an object that does not have this attribute. It's likely that 'WellDressedSkyBlueSardine' is a security symbol and you're trying to access its fundamental data. In QuantConnect, you can access a security's fundamental data using the Securities property of the algorithm object, like so: self.Securities[symbol].Fundamentals.

2. '<' not supported between instances of 'NoneType' and 'float': This error suggests that you are trying to compare a None value with a float, which is not allowed in Python. This could happen if some of the elements in alt_coarse have None as their sentiment_30_days value. You can avoid this error by filtering out these elements before sorting, like so: sorted([x for x in alt_coarse if x.sentiment_30_days is not None], key=lambda x: x.sentiment_30_days, reverse=True).

Without seeing your full code, it's hard to provide a more specific solution. However, I hope these suggestions help you debug your code. If you continue to have issues, I recommend posting your full code and error messages on the QuantConnect Forum for more detailed assistance.

You've been so helpful, thank you very much. I got rid of the errors with your suggestions but now but the fine filter is not pulling any data from the BrainSentiment Indicator and returns an empty list.

Any idea why? I'm so cloes now….

I've added the backtest if you have a chance to check it out.

Cheers,

AA

Based on the code you provided, it seems like the issue might be with how you're trying to intersect the self.fundamental and sortedby30daySentiment lists in the universe_selection function.

In this line: self.list = list(set(self.fundamental) & set(sortedby30daySentiment)), you're trying to find the intersection of self.fundamental (a list of Symbols) and sortedby30daySentiment (a list of BrainSentimentIndicatorUniverse objects). Since these two lists contain different types of objects, their intersection will always be an empty list.

To fix this issue, you should make sure that both lists contain the same type of objects before trying to find their intersection. For example, you could modify the universe_selection function like this:

def universe_selection(self, alt_coarse: List[BrainSentimentIndicatorUniverse]) -> List[Symbol]:
    if self.Time <= self.rebalanceTime:
        return self.Universe.Unchanged
    self.rebalanceTime = self.Time + timedelta(30)
    sortedby30daySentiment = [x.symbol for x in sorted([x for x in alt_coarse if x.sentiment_30_days is not None], key=lambda x: x.sentiment_30_days, reverse=True)]
    return list(set(self.fundamental) & set(sortedby30daySentiment))

In this modified version of the function, sortedby30daySentiment is a list of Symbols, just like self.fundamental. Therefore, their intersection will be a list of Symbols that pass both the price filter and the sentiment filter.

I hope this helps! If you have any more questions, feel free to ask.