P/E info missing for many stocks

import numpy as np
from typing import List
from AlgorithmImports import *

class QuarterlyRebalancingAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2019, 1, 1)
        self.set_end_date(2019, 12, 1)
        self.set_cash(100000)
        self.add_universe(self.coarse_selection_function, self.fine_selection_function)
        self.schedule.on(self.date_rules.month_start(1), self.time_rules.at(9, 31), self.liquidate_positions)
        self.schedule.on(self.date_rules.month_start(1), self.time_rules.at(9, 35), self.rebalance)
        self.set_security_initializer(lambda security: security.set_fee_model(ConstantFeeModel(1)))
        self.set_security_initializer(lambda security: security.set_slippage_model(ConstantSlippageModel(0.001)))
        self.quarterly_rebalance = False
        self.selected_symbols: List[Symbol] = []
        self.liquidate_positions_counter = 0
        self.rebalance_counter = 0

    def liquidate_positions(self):
        if self.liquidate_positions_counter == 0 or self.liquidate_positions_counter == 3:
            for symbol in list(self.portfolio.keys()):
                self.liquidate(symbol)
            self.liquidate_positions_counter += 1
            if self.liquidate_positions_counter >= 3:
                self.liquidate_positions_counter = 1
        else:
            self.liquidate_positions_counter += 1

    def rebalance(self):
        if self.rebalance_counter == 0 or self.rebalance_counter == 3:
            weight = 1 / 10
            for symbol in self.selected_symbols:
                self.log(",".join([str(symbol.value) for symbol in self.selected_symbols]))
                self.set_holdings(symbol, weight)
            self.rebalance_counter += 1
            if self.rebalance_counter >= 3:
                self.rebalance_counter = 1  
        else:
            self.rebalance_counter += 1

    def coarse_selection_function(self, coarse):
        filtered = [x for x in coarse if x.price > 0.5]
        filtered = [x for x in filtered if not x.symbol.value.endswith(".OB")]
        return [x.symbol for x in filtered]

    def fine_selection_function(self, fine: List[FineFundamental]) -> List[Symbol]:
        selected_securities = []
        sortedsec = []
        selected = [c for c in fine if c.has_fundamental_data and not np.isnan(c.valuation_ratios.pe_ratio)]
        for f in selected:
            if f is not None:
                if f.market_cap >= 50000000 and f.valuation_ratios.pe_ratio is not None and f.valuation_ratios.pe_ratio > 0:
                    selected_securities.append(f)
        sorted_securities = sorted(selected_securities, key=lambda x: x.valuation_ratios.pe_ratio, reverse=False)            
        sortedsec = [c.symbol for c in sorted_securities]
        return sortedsec[:10]

    def on_securities_changed(self, changes: SecurityChanges) -> None:
        self.selected_symbols = []
        for security in changes.added_securities:
            self.selected_symbols.append(security.Symbol)

Sources: 12 Month Cycle In Cross Section Of Stocks Returns, Asset Growth Effect, Liquidity Effect In Stocks, Momentum Effect In Stocks In Small Portfolios, Accrual Anomaly

Anyone else have this problem or know how to get the coarse and fine filters to provide accurate ascending lists of securities with the lowest P/E that will be chosen quarterly?

Anyone?