ps6_term_list.py

""" Classes to create a list of PySide6 classes and Enums """
from dataclasses import dataclass
import inspect
from enum import Enum
from PySide6 import QtCore, QtGui, QtWidgets


@dataclass
class TermEntry:
    """ PySide6 class|enum info """
    display: str        # display name
    search: str         # search name
    suffix: str         # URL suffix


class PS6TermList:
    """ Build a list of PySide6 classes and enums """
    BASE_URL = 'https://doc.qt.io/qtforpython-6/PySide6/'
    SKIPS = ['ClassInfo', 'MetaFunction', 'MetaSignal', 'PyClassProperty']
    MODS = (QtCore, QtGui, QtWidgets)

    def __init__(self):
        self.terms: list[TermEntry] = []
        self.kls_count = 0
        self.enum_count = 0

        for mod in self.MODS:
            mod_name = mod.__name__.split('.', 1)[1]
            # Get the names of all the classes in this module
            for kls_name, kls in inspect.getmembers(mod, inspect.isclass):
                if not kls_name in self.SKIPS:
                    kls_url = f'{mod_name}/{kls_name}.html'
                    self.terms.append(TermEntry(f'{mod_name}.{kls_name}',
                                                kls_name.lower(),
                                                kls_url))
                    self.kls_count += 1

                    # Get the names of all the Enums in this class
                    for _, en in inspect.getmembers(kls, self.is_enum):
                        qname = en.__qualname__
                        # Ensure this Enum belongs to this class (not inherited)
                        if qname.startswith(kls_name):
                            # enums are #fragments on superclass page
                            e_url = f'{kls_url}#{mod.__name__}.{qname}'
                            self.terms.append(TermEntry(qname,
                                                        qname.lower(),
                                                        e_url))
                        self.enum_count += 1

        self.terms.sort(key=lambda t: t.display)

    @staticmethod
    def is_enum(member):
        # inspect.getmembers() helper
        return inspect.isclass(member) and issubclass(member, Enum)

    def search(self, search_term: str) -> list[TermEntry]:
        """ Return list of terms that include <search_term> """
        terms: list[TermEntry] = []
        if len(search_term) >= 3:       # too many results for 1- and 2-char searches
            term = search_term.lower()
            terms = [entry for entry in self.terms if term in entry.search]
        return terms

    def make_url(self, entry: TermEntry) -> str:
        """ Return doc URL for the specified term """
        return self.BASE_URL + entry.suffix

    def stats(self) -> str:
        return f'{self.kls_count} classes and {self.enum_count} enums available'