For the architecture of this particular logger case. Since you have to derive from logging.Handler, why don't you encapsulate the QPlainTextEdit in your class instead of multiple-inheriting from it? My initial thought is that would be preferable. Then you would not multiple-inherit and you wouldn't have the current problem, whatever it is.

Finally I decided to encaplusate logging.Handler in my class and now I like it more than before :)
The bug was confirmed in PySide and to be corrected in future versions but everything works good without multiple inheritance.

Also initial code was not ideal and was different from Qt recommendations.

So, with both things changed I have my code up and running again.

Collecting PySide6
Using cached PySide6-6.5.0-cp37-abi3-win_amd64.whl (7.2 kB)

No idea why it use 3.7

I'll put a note on the issue page that you pointed to.

Please do so. I don't know whether they will say it is a 6.5.0 issue or whether they will say your code is wrong/the behaviour you see is correct.

Thanks for all the help with this, it's been invaluable. I found the root cause of our problem. The order that the base classes are inherited in affects the Method Resolution Order, which confuses the new system.

I think it points to an error in PySide 6.5.0, but I don't have enough knowledge of the inner workings of Python and PySide to make a call on this. I'll put a note on the issue page that you pointed to.

The PR to fix this in USD is here, which goes into an explanation of the issue:

https://github.com/PixarAnimationStudios/USD/pull/2392

It sounds like:

• There was a problem with multiple inheritance at 6.4 which they fixed at 6.5, or they just changed/improved it, per the changes.

• Now at 6.5 that may be fixed/improved, but other cases, such as yours and @StarterKit's, go wrong, where they used to be OK at 6.4.

I do not truly understand the discussion in https://bugreports.qt.io/browse/PYSIDE-2294 or what the conclusion was. You may need to post there, or raise a new issue.

One thing: I see you use super(QtCore.QObject, self).__init__(self) in both your cases. But @SGaist wrote

This is wrong, self shall not be part of the arguments passed to the function called when using super.
super().init(parent=parent)

So is not that the issue?

At this point I am passing here, as it's becoming a Python issue I am not sufficiently familiar with.

It looks like the change that came into 6.5.0 was this:

https://github.com/pyside/pyside-setup/commit/e8095467f7d0332cc0987e7c541de9906e19fece

And this has caused the regression?

That does sound like the same issue, but as you say it's not clear in the discussion whether there is actually a fix in 6.6.0 or not?

I'll check in with them there.

Cheers,

Jon

This makes me think it's a new bug that has been introduced into the handling of multiple inheritance in PySide.

I don't know enough about the inner workings of PySide, perhaps someone on this forum can shed some light on it?

    def __init__(self, rootDataModel, parent):
        super(QtCore.QObject, self).__init__(self)
        StateSource.__init__(self, parent, "model")

This results in a runtime error of:

    QtCore.QObject.__init__(self)
TypeError:__init__() missing 2 required positional arguments: 'parent' and 'name'

If I reverse the order of initialisation to:

    def __init__(self, rootDataModel, parent):
        StateSource.__init__(self, parent, "model")
        super(QtCore.QObject, self).__init__(self)

Then the error reports that the StateSource initialiser only should have a single parameter.

That is indeed the best, but earlier you said

I thought one more time about it and decided that there is a better desing option possible :) Not a big change but I moved 2 more methods inside my class and it looks good after all :)

Finally I decided to encaplusate logging.Handler in my class and now I like it more than before :)

That is indeed the best, but earlier you said

But your handler should be a descendant of logging.Handler.

Anyway, sounds good :)

For the architecture of this particular logger case. Since you have to derive from logging.Handler, why don't you encapsulate the QPlainTextEdit in your class instead of multiple-inheriting from it? My initial thought is that would be preferable. Then you would not multiple-inherit and you wouldn't have the current problem, whatever it is.

Finally I decided to encaplusate logging.Handler in my class and now I like it more than before :)
The bug was confirmed in PySide and to be corrected in future versions but everything works good without multiple inheritance.

Also initial code was not ideal and was different from Qt recommendations.

So, with both things changed I have my code up and running again.

But I try to understand how super() works based on information that I collected.
And I'm a bit puzzled now...
Here is my old code:

import logging
from PySide6.QtWidgets import QApplication, QPlainTextEdit

class LogViewer(QPlainTextEdit, logging.Handler):
    def __init__(self, parent=None):
        QPlainTextEdit.__init__(self, parent)     # this line will be changed
        logging.Handler.__init__(self)            # this line will be changed

app = QApplication([])
window = LogViewer()
window.show()
print(f"LEVEL: {window.level}")
app.exec() 

It works and prints LEVEL: 0 as expected.
But based on all these discussions I decided to change it and use super() and got this code:

import logging
from PySide6.QtWidgets import QApplication, QPlainTextEdit

class LogViewer(QPlainTextEdit, logging.Handler):
    def __init__(self, parent=None):
        super().__init__(parent=parent)     # this line was changed

app = QApplication([])
window = LogViewer()
window.show()
print(f"LEVEL: {window.level}")
app.exec() 

And this code fails with AttributeError: 'LogViewer' object has no attribute 'level' - it appears that logging.Handler ancestor didn't become a part of window object... I don't understand what is wrong in this case... Any hints?...

I played a bit and changed 2nd example to use different class order: class LogViewer(logging.Handler, QPlainTextEdit) and it gave me TypeError: Handler.__init__() got an unexpected keyword argument 'parent' that raises a feeling that something is not right...

With regards to your question about inheritance. I use Qt Designer to create UI layout. So for me it is easier to have Qt-based class that I may use in Qt Designer and simply put an object on form with help of mouse. This is why I inherited from QPlainTextEdit.
I may do it other way around and make another class that would be derived from logging.Handler and then use it as a member of my class. But these two classes will be tightly coupled and won't work one without another.
So... if one way I lose benefits of Qt, another way I have bad design... - and then, why would we have multiple inheritance at all? :) I created this class some time ago and it survived migration from Qt 5 to Qt 6... But now it fails with Qt 6.5.0 :(

@SGaist said in TypeError with PySide 6.5.0 for multiple inheritance of MainWindow:

This is wrong, self shall not be part of the arguments passed to the function called when using super.
super().init(parent=parent)

That's what he said. I'm not sure enough about my Python to answer, maybe no harm in trying :)

It would be interesting to know if there is a PyQt6.5.0 and how it handles your existing code. You say it was working at 6.4.3, I don't know whether the PySide 6.5 is correct or not.

For the architecture of this particular logger case. Since you have to derive from logging.Handler, why don't you encapsulate the QPlainTextEdit in your class instead of multiple-inheriting from it? My initial thought is that would be preferable. Then you would not multiple-inherit and you wouldn't have the current problem, whatever it is.

super(QPlainTextEdit, self).__init__(parent)
super(logging.Handler, self).__init__()

instead of:

QPlainTextEdit.__init__(self, parent)
logging.Handler.__init__(self)

?

So, I use python logging module in my app. Traditionally it prints messages to a console by default. You may redirect it to file or something else.

But you may do whatever you want if you create you own handler and pass it to logging.addHandler() method. But your handler should be a descendant of logging.Handler.

So, I use Qt to have GUI and I deciced to put logging output into a Plain text editor.
As result I created a class that is descendant of both - QPlainTextEdit and logging.Handler:

class LogViewer(QPlainTextEdit, logging.Handler):
    def __init__(self, parent=None):
        QPlainTextEdit.__init__(self, parent)
        logging.Handler.__init__(self)
        # Other initialization

    def emit(self, record, **kwargs):
        # log record handling

and then I use it:

self.Logs = LogViewer(parent_widget)
self.logger = logging.getLogger()
self.logger.addHandler(self.Logs)

And as result I have exactly the same prolem TypeError: Level not an integer or a valid string because now it tries to pass parent_widget to logging.Handler constructor.

  File "main.py", line 10, in __init__
    super().__init__(parent=None)
TypeError: object.__init__() takes exactly one argument (the instance to initialize)

It only works if I put nothing:

super().__init__()

but... in this case I have a failure in another part of my code... (I'm still looking into it but it appears without parent=None some other widget behaves wrong...)

@StarterKit
If you replace your
QMainWindow.__init__(self, parent=None)
by
super().__init__(self, parent=None)
does it make the problem go away?

This is wrong, self shall not be part of the arguments passed to the function called when using super.

super().__init__(parent=parent)

If that does not solve, not that you should have to but try omitting the , parent=None in both the QMainWindow and the super() cases.

I currently don't have a direct answer for this new issue however, the use of super is more common in code designed with Qt for Python. Even more so in Python 3 code bases.

You can see some good reasons here as to why.