• 4 Posts
  • 103 Comments
Joined 1 year ago
cake
Cake day: March 1st, 2024

help-circle

  • Think the quote is premature optimization is the root of all evil. Don’t know who came up with that famous expression.

    In the case of the code in the process guard, perhaps you are right.

    In the case of embedding a class within FoldableDockWidget, it’s simply a case of don’t do that, not optimization.

    Hardwiring a particular implementation of the Windowing python wrapper is necessary.

    qasync

    Python library for using asyncio in Qt-based applications

    ^^ is the package to support them all.

    This comes directly from an app i wrote,

    from qasync import (asyncSlot, QtWidgets, QtGui, QtCore, _make_signaller)

    Here is some code which deals with differences between implementations

    from qasync import (QtWidgets, QtCore, QtGui, QtModuleName)
    
    __all__ = ["QtportQAction", "QtportQScreen", "QtportQScreenImplementation"]
    
    try:
        QtportQAction = QtWidgets.QAction
    except AttributeError as e:
        #"PySide6", "PyQt6"
        QtportQAction = QtGui.QAction
    
    try:
        QtportQScreen = QtWidgets.QDesktopWidget
        QtportQScreenImplementation = "QDesktopWidget"
    except AttributeError as e:
        QtportQScreen = QtGui.QScreen
        QtportQScreenImplementation = "QScreen"
    

    So it can be done!

    In the case of this gist, it’s premature optimization. Generally it’s necessary cuz new implementations come along often.



  • There already exists multiple build backends. So adding one more can’t be violating some rule.

    Are there gatekeepers who say it’s ok for them but not for anyone else? Do i have to bribe them to be in the in crowd? Am i lower class or an outcast?

    This reminds me of proof of stake (1998) with it’s master nodes. Which are nodes run by elites where pleb nodes are lessor.

    bitcoin (2009) solved that





  • There are very few one package to rule them all in Python. There are always various similar yet different packages.

    Gotta breakdown what you are trying to accomplish. And find packages that do only that. Packages which combine many things into one, might lead to not understanding how it’s doing what it’s doing.

    desired build backend features

    • supports build plugins

    • bypasses the pip limitation of not being able to pass build configs options thru to the build backend subprocess

    deal breaker (bad) in a build backend:

    • deals with requirements

    • written in a coding another language you are not familiar with (Rust or node or Go)





  • Arguing for modularity. Which isn’t likely in a gist (or a script), but is normal for a package.

    By embedding the class, creates a limitation that prevents abstractions or other implementations of each component. Imagine every suggestion in this conversation thread is another variation with a separate implementation.

    The widget class belongs to the FoldableDockWidget class until it doesn’t. Then a refactor is needed.

    There should be four modules. The entrypoint (and cli options parsing), the application, the dockwidget, and the widget. Each should be testable by itself.

    A widget is not a container. An application is not a container component (avoiding the word widget). Hardwiring a particular implementation of the Windowing Python wrapper is also unnecessary (PySide6). What about PySide2, pyQt5, pyQt6, and whatever else comes next?

    As a side note

    Why is there code in the process guard, besides main() (or a async equivalent)? Only multiprocessing applications have code within the process guard. Code within the process guard is unreachable; can’t be imported. For example, testing just the cli option parsing.


  • Lets fix the Sphinx in-code documentation (Ignoring should never embed classes within other classes)

    class FoldableDockWidget(QDockWidget):
        """
        A simple Qt Widget that adds a 'minimise' button that vertically reduces the dock widget to just the titlebar to
        allow the dock widget to still take up minimal screen real estate
        """
    
        class TitleBarWidget(QWidget):
            def __init__(self, title:str, parent:QWidget=None):
                """
                We create a custom title bar using QWidget as the base. The title bar has to be wrapped in another widget
                so that its background can be styled easier, otherwise it's impossible to style
                :param title: the title to appear in the title bar
                """
    

    Becomes

    class FoldableDockWidget(QDockWidget):
        """
        A simple Qt Widget that adds a 'minimise' button that vertically reduces the dock widget to just the titlebar to
        allow the dock widget to still take up minimal screen real estate
        """
    
        class TitleBarWidget(QWidget):
        """Create a custom title bar using :py:class:`~PySide6.QtWidgets.QWidget` as the base.
        The title bar has to be wrapped in another widget so that its background can be styled
        easier, otherwise it's impossible to style
    
        :ivar title: the title to appear in the title bar
        :vartype title: str
        :ivar parent: Default None. Identify parent widget
        :vartype parent: PySide6.QtWidgets.QWidget | None
        """
    
            def __init__(self, title: str, parent: QWidget = None) -> None:
                """class constructor"""
    

    typing matters. Normally separate typing into stub files. The Sphinx in-code documentation includes typing, so the signatures can be simplified and easier to read

    def __init__(self, title, parent=None):


  • from PySide6.QtWidgets import QDockWidget, QWidget, QToolButton, QStyle, QHBoxLayout, QStyleFactory, QSizePolicy, \
        QApplication, QVBoxLayout, QLabel, QSlider, QMainWindow, QSizeGrip
    

    No code should be more than 80 characters UNLESS it’s unavoidable like with a long regex. Hard limit is normally 88 characters.

    Should be

    from PySide6.QtWidgets import (
        QDockWidget,
        QWidget,
        QToolButton,
        QStyle,
        QHBoxLayout,
        QStyleFactory,
        QSizePolicy,
        QApplication,
        QVBoxLayout,
        QLabel,
        QSlider,
        QMainWindow,
        QSizeGrip,
    )
    

    Or add parenthesis and the last comma. black will reformat it. Then use isort to fix imports ordering.

    Get that you are sharing this as a gist. Normally code like this is broken up into multiple modules so it’s easier on the eyes and less going on.