Complicated QSortFilterProxyModel.setFilterRegex. Is it possible to match within a match?

Question

I'm looking for help on a tricky QRegExp that I'd like to pass to my QSortFilterProxyModel.setFilterRegex. I've been struggling to find a solution that handles my use-case.

From the sample code below, I need to capture items with two underscores (_) but ONLY if they have george or brian. I do not want items that have more or less than two underscores.

string_list = [
'john','paul','george','ringo','brian','carl','al','mike',
'john_paul','paul_george','john_ringo','george_ringo',
'john_paul_george','john_paul_brian','john_paul_ringo',
'john_paul_carl','paul_mike_brian','john_george_brian',
'george_ringo_brian','paul_george_ringo','john_george_ringo',
'john_paul_george_ringo','john_paul_george_ringo_brian','john_paul_george_ringo_brian_carl',
]

view = QListView()
model = QStringListModel(string_list)
proxy_model = QSortFilterProxyModel()
proxy_model.setSourceModel(model)
view.setModel(proxy_model)
view.show()

The first part (matching two underscores) can be accomplished with the line (simplified here, but really each token can be composed of any alphanumeric character other than _, so [a-zA-Z0-9]*):

proxy_model.setFilterRegExp('^[a-z]*_[a-z]*_[a-z]*$')

The second part can be accomplished (independently with)

proxy_model.setFilterRegExp('george|brian')

To complicate matters, these additional criterial apply:

• This list may grow to the realm of several thousand items,
• The tokenization may reach up to 10 or so tokens
• The tokenization can be in any order (so george could occur at the beginning, middle, end)
• We may also want to also capture georgeH and brainW35 when they occur, so long as they begin with george or brian.
• We may have N-Number of names we're searching for (i.e. george|brian|jim|al, but only when they're in strings with two underscores.

To simplify them:

• Lines will never begin or end with "_", and should only ever begin/end with [a-zA-Z0-9]

Do the QRegExp and QSortFilterProxyModel even have the capabilities I'm looking for, or will I need to resort to some other approach?

Answer 1

For very complex conditions using regex is not very useful, in that case it is better to override the filterAcceptsRow method where you can implement the filter function as shown in the following trivial example:

class FilterProxyModel(QSortFilterProxyModel):
    _words = None
    _number_of_underscore = -1

    def filterAcceptsRow(self, source_row, source_parent):
        text = self.sourceModel().index(source_row, 0, source_parent).data()
        if not self._words or self._number_of_underscore < 0:
            return True
        return (
            any([word in text for word in self._words])
            and text.count("_") == self._number_of_underscore
        )

    @property
    def words(self):
        return self._words

    @words.setter
    def words(self, words):
        self._words = words
        self.invalidateFilter()

    @property
    def number_of_underscore(self):
        return self._number_of_underscore

    @number_of_underscore.setter
    def number_of_underscore(self, number):
        self._number_of_underscore = number
        self.invalidateFilter()

view = QListView()
model = QStringListModel(string_list)
proxy_model = FilterProxyModel()
proxy_model.setSourceModel(model)
view.setModel(proxy_model)
view.show()

proxy_model.number_of_underscore = 2
proxy_model.words = (
    "george",
    "brian",
)