How to Access Fundamental Data for list of Equities

I found this below but as PE ratio and changed it to market cap, but I still have no idea what it's doing or how it's doing it.

My end goal is if I could call on all the tradable stocks and check the market cap then run my analysis on those that fit my market cap criteria that would be awesome, but I have no idea how to do this still

from AlgorithmImports import *
from System.Collections.Generic import List

class CoarseFineFundamentalComboAlgorithm(QCAlgorithm):

    def Initialize(self):
        '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''

        self.SetStartDate(2022,1,1)  #Set Start Date
        self.SetCash(50000)            #Set Strategy Cash

        # what resolution should the data *added* to the universe be?
        self.UniverseSettings.Resolution = Resolution.Daily

        # this add universe method accepts two parameters:
        # - coarse selection function: accepts an IEnumerable<CoarseFundamental> and returns an IEnumerable<Symbol>
        # - fine selection function: accepts an IEnumerable<FineFundamental> and returns an IEnumerable<Symbol>
        self.AddUniverse(self.SelectCoarse, self.FineSelectionFunction)

        self.__numberOfSymbols = 5000
        self.__numberOfSymbolsFine = 100
        self._changes = None

    def SelectCoarse(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        selected = [c for c in coarse if c.HasFundamentalData]
        sorted_by_dollar_volume = sorted(selected, key=lambda c: c.DollarVolume, reverse=True)
        return [ c.Symbol for c in sorted_by_dollar_volume[:20] ]

    # sort the data by Market Cap and take the top 'NumberOfSymbolsFine'
    def FineSelectionFunction(self, fine):
        # sort descending by Market Cap ratio
        sortedByPeRatio = sorted(fine, key=lambda x: x.MarketCap, reverse=True)

        # take the top entries from our sorted collection
        return [ x.Symbol for x in sortedByPeRatio[:self.__numberOfSymbolsFine] ]

    def OnData(self, data):
        # if we have no changes, do nothing
        if self._changes is None: return

        # liquidate removed securities
        for security in self._changes.RemovedSecurities:
            if security.Invested:
                self.Liquidate(security.Symbol)

        # we want 20% allocation in each security in our universe
        for security in self._changes.AddedSecurities:
            self.SetHoldings(security.Symbol, 0.2)

        self._changes = None


    # this event fires whenever we have changes to our universe
    def OnSecuritiesChanged(self, changes):
        self._changes = changes

Figured it out! I'm still not sure how it works but I believe that it adds every single ticker to the universe in the course setting and then filters out those by market cap using the fine selection. Hope someone can find this usefull!

from AlgorithmImports import *
from System.Collections.Generic import List

class CoarseFineFundamentalComboAlgorithm(QCAlgorithm):

    def Initialize(self):
        '''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''

        self.SetStartDate(2023,1,1)
        self.SetCash(50000)

        # what resolution should the data *added* to the universe be?
        self.UniverseSettings.Resolution = Resolution.Daily

        # this add universe method accepts two parameters:
        self.AddUniverse(self.SelectCoarse, self.FineSelectionFunction)

        self.maxcap = 10000 * 1000000000 #seccond number is 1B
        self.mincap = 1000 *1000000000 #seccond number is 1B

        self._changes = None

    #Add all tickers with fundamental data to universe
    def SelectCoarse(self, coarse: List[CoarseFundamental]) -> List[Symbol]:
        selected = [c for c in coarse if c.HasFundamentalData]
        return [ c.Symbol for c in selected ]

    #filter out thoes by market cap
    def FineSelectionFunction(self, fine):
        # sort descending by Market Cap
        marketcapfit = [x for x in fine if x.MarketCap>self.mincap and x.MarketCap<self.maxcap]

        # take the top entries from our sorted collection
        return [ x.Symbol for x in marketcapfit ]

    def OnData(self, data):
        # liquidate removed securities
        for security in self._changes.RemovedSecurities:
            if security.Invested:
                self.Liquidate(security.Symbol)

        # we want x% allocation in each security in our universe
        for security in self._changes.AddedSecurities:
            self.SetHoldings(security.Symbol, 0.3)

        self._changes = None


    # this event fires whenever we have changes to our universe
    def OnSecuritiesChanged(self, changes):
        self._changes = changes