I have an existing class which inherits from the PyQT5 classes QWidget and Ui_Dialog.
I want to use some functionality of the class which is not at all related to the GUI. I have therefore tried to mock out the relevant bits, such as the __init__ function which has a lot of GUI-specific code. There is also a specific method in the class which needs overriding (_getSqlQuery).
class TestPyQgs(unittest.TestCase):
def test_comment_parsing(self):
query = "SELECT * FROM test"
with patch.object(DlgSqlWindow, "__init__", lambda x, y, z: None):
with patch.object(DlgSqlWindow, "_getSqlQuery", return_value=query):
a = DlgSqlWindow(None,None)
self.assertEqual(a.parseSQL(), query)
Unfortunately this doesn't work because anything that inherits from QtWidget (as DlgSqlWindow does) has to call init on the Base Class, so I get super-class __init__() of type DlgSqlWindow was never called. Is there no sane way of doing this? Otherwise should I try and refactor the code to split GUI from functionality, or do a unit test on the GUI as well, which I would rather not do as I want the unit test to be as tight as possible.
One possible solution is to just call the super QWidget who doesn't have much logic:
import unittest
from unittest.mock import patch
from PyQt5 import QtWidgets
class Ui_Dialog(object):
def setupUi(self, dialog):
pass
class DlgSqlWindow(QtWidgets.QWidget, Ui_Dialog):
def _getSqlQuery(self):
pass
def parseSQL(self):
return "SELECT * FROM test"
def init(self, *args):
QtWidgets.QWidget.__init__(self)
# self.setupUi(self)
class TestPyQgs(unittest.TestCase):
def test_comment_parsing(self):
app = QtWidgets.QApplication([])
query = "SELECT * FROM test"
with patch.object(DlgSqlWindow, "__init__", init):
with patch.object(DlgSqlWindow, "_getSqlQuery", return_value=query):
a = DlgSqlWindow(None, None)
self.assertEqual(a.parseSQL(), query)
if __name__ == "__main__":
unittest.main()
But as you point out, the optimal solution is to refactor your code since it seems that you are mixing business logic with the GUI which, as you can see, causes several inconveniences and is not maintainable.
Related
I would like to "increase" an existing signal (currentIndexChanged in example above) to make it able to return another type:
from PySide import QtCore, QtGui
class MyClass(object):
pass
class MyClassComboBox(QtGui.QComboBox):
#QtCore.Signal(int, result=MyClass)
def currentIndexChanged(self, *args):
my_class_instance = self._id_to_my_class(args[0])
return my_class_instance
class MyClassWidget(QtGui.QWidget):
def __init__(self, *args, **kwargs):
super(MyClassWidget, self).__init__(*args, **kwargs)
cb = MyClassComboBox(self)
cb.currentIndexChanged[MyClass].connect(self.do_it)
def do_it(self, *args):
assert isinstance(args[0], MyClass)
print args
As you guess, this code doesn't work because of #QtCore.Signal(int, result=MyClass). As you guess, the idea is to register an existing signal (currentIndexChanged) to return a given, custom type (MyClass).
Any idea on how I can do this?
Messing with existing Qt signals doesn't sound like a good idea. If you need to pass additional or modified arguments to a slot when a signal is emitted, you can do so with a lambda function.
While it's not entirely clear what you are trying to achieve from your example, you probably want something like this
cb.currentIndexChanged.connect(lambda i: self.do_it(MyClass(i)))
Some environment basics
Python Version: 3.4.2
OS: Windows 8.1
Searching so far, I suspect this other question is related to my issue at hand, but I'm not sure how I'm replicating enough of the same conditions--probably my lack of in-depth python knowledge.
Simplified code to reproduce issue:
Base Class
from PySide.QtGui import *
class Interface(QWidget):
'''
Wrapper base class for GUI input QWidgets:
- buttons
- text fields
- checkboxes
- line edit
- dropdown menu (combo box)
'''
def __init__(self, parent, name, title_txt=None, qt_obj=None,
update_log_method=None):
print('Interface base class constructor has been called.') #DEBUG
self._parent = parent
self.title = None
self.name = name #also text that appears on component
self.qt_obj = qt_obj
self.inheritted_log_method = update_log_method
# don't want to create an empty text QLabel, or one with
# the text reading "None".
if title_txt:
self.title = QLabel(text=title_txt, parent=parent)
print('Interface base class constructor has been completed.') #DEBUG
def get_name(self):
return self.name
def update_log(self, message, level="INFO"):
''' '''
self.inheritted_log_method(message, level)
Inheriting Class
class IFPushButton(Interface):
''' '''
def __init__(self, name, parent, icon=None, update_log_method=None):
''' '''
# print('\n\nCHECKPOINT: pre IFPushButton super()\n\n') #DEBUG
super(IFPushButton, self).__init__(
parent=parent,
name=name,
qt_obj=QPushButton(icon, name, parent),
update_log_method=update_log_method)
self.behaviors = {}
self.qt_obj.clicked.connect(self.activate)
Something to kick it all off
if __name__ == '__main__':
# setup
import sys
app = QApplication(sys.argv)
qmw = QMainWindow()
qcw = QWidget() #central widget
qcl = QVBoxLayout(qcw) #central layout
# experimental
name = 'named button'
ifpb = IFPushButton(name=name, parent=None, icon=None, update_log_method=None)
print("as long a I don't touch the ifpb instance, everything seems to be okay.")
print("...but the second I do...")
qcl.addWidget(ifpb)
self.show()
print("name of created push button:", ifpb.get_name())
# proper teardown
sys.exit(app.exec_())
I run this all inside one module, interface.py, and when I run it...
C:\Path\To\Module> python interface.py
Interface base class constructor has been called.
Interface base class constructor has been completed.
as long a I don't touch the ifpb instance, everything seems to be okay.
...but the second I do...
Traceback (most recent call last):
File "c_interface.py", line 167, in <module>
qcl.addWidget(ifpb)
RuntimeError: '__init__' method of object's base class (IFPushButton) not called.
The part that confuses me is how the print statements in the base class, Intefrace, are obviously being called as they are printing--but it still raises a RuntimeError saying that it hasn't been initialized, and of course fails to get so far as to create the app window. Most of the related messages I've found on stackoverflow are related to people initializing things incorrectly with the super() method--but I have quintuple-checked my super inits, and everything I see tells me it should be working, with the exception of what I linked above.
If I could understand more about why this is happening I'm hoping I can find a way to work around it. Any assistance is much appreciated--thanks in advance!
In the meantime I'm going to try to find how I might be unintentionally deepcopy-ing a C++ object...
EDIT: included the url in the link to other stack overflow post.
Adding a super call to the Interface class constructor is required:
def __init__(self, parent, name, title_txt=None, qt_obj=None, update_log_method=None):
super(Interface, self).__init__(parent)
...
Also, you're calling self.show(), where you probably mean qmw.show().
I think my answer is related to this answer but can't quite get my head around it.
I am now realising that my code isn't structured very well, however the current setup is:
main_run.py
app = QtGui.QApplication(sys.argv)
app.processEvents()
ui1 = new_main_ui.Ui_Form_Main()
ui1.show()
sys.exit(app.exec_())
new_main_ui
class Ui_Form_Main(QtGui.QWidget):
def __init__(self):
QtGui.QWidget.__init__(self)
self.setupUi(self)
...etc...
within this class are Qlabel objects which have their text updated as buttons are pressed on the UI.
within new_main_ui there is a call to another module (sqr_pull.py) which does some stuff. Halfway through sqr_pull.py I want to update a Qlabel in my UI, but I can't figure out how to reference the UI instance (ui1) without getting:
NameError: name 'ui1' is not defined
I've tried trying to pass variables through as I go using sys.modules[__name__] as follows:
in main_run: new_main_ui.parent1 = sys.modules[__name__]
in new_main_ui: sqr_pull.parent2 = sys.modules[__name__]
and then in sqr_pull trying to change using `parent2.QLabel.setText("blahblahblah")
but it again doesn't recognise the instance name. What's the best way to do this?
The clean way to give a function access to an object is to pass this object to the function...
# worker.py
def work(ui):
some_result = do_something()
ui.update(some_result)
other_result = do_something_else()
# ui.py
import worker
class Ui(object):
def some_action(self):
worker.work(self)
def update(self, data):
self.show_data_somewhere(data)
Hacking with sys.modules or whatever will only result in some unmaintainable mess.
Am struggling to comprehend how to split code in (Py)Qt. The aim is to have the design & navigation tabs in QMainWindow, each tab triggering code in other files. So far it only launches with the ActionClass in the same document / putting in an external document causes 'app not defined' when clicking the tab. The below works without errors, but is clunky.
class Main(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.u = Ui_MainWindow()
self.u.setupUi(self)
self.u.tabs.currentChanged.connect(self.TabsChanged)
def TabsChanged(self, i):
if i == self.u.tabs.indexOf(self.u.tabFirst): ActionClass.__init__
class ActionClass(Main):
def __init__(self):
app.u.lineEdit.setText("test")
app = Main()
app.show()
sys.exit(app.exec_())
The examples I keep seeing have all code in one document. Is there another way to do this e.g. where the ActionClass is in another file/writing u.lineEdit.setText instead of app.u.lineEdit.setText. It seems inheritance & an instance of Main can't be accessed from the ActionClasses doc, so I can't see how they would communicate back to the Main?
Much appreciated
As suggest #M4rtini you can separate your code into python modules. And then import them (use them) in your main module.
For instance the code you posted can be separated in to files:
# actions_class.py
class ActionClass(Main):
def __init__(self):
app.u.lineEdit.setText("test")
and
# main.py
from action_class import ActionClass # This line no need much explanation ;)
class Main(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.u = Ui_MainWindow()
self.u.setupUi(self)
self.u.tabs.currentChanged.connect(self.TabsChanged)
def TabsChanged(self, i):
if i == self.u.tabs.indexOf(self.u.tabFirst): ActionClass.__init__
app = Main()
app.show()
sys.exit(app.exec_())
In order to understand how import works see the link I left you above.
More explanation
Lest's see:
The correct way of executin code inside a __init__ method is creating an instance. See the example below.
class A:
def __init__(self):
print("Executing A.__init__")
print("Doing things wrong")
A.__init__ # This don't print enything
print("Doing things well")
A() # This works as expected.
So, you line reads:
if i == self.u.tabs.indexOf(self.u.tabFirst): ActionClass.__init__
and should reads:
if i == self.u.tabs.indexOf(self.u.tabFirst): ActionClass()
On the other hand, is a bad practice put code that's not for initialize the instance inside the __init__ methods.
If you don't need the instance but yet you want to store the functions inside a class (something like a c++ namespace) you creating
use #staticmethod decorator.
class A:
#staticmethod
def foo():
print("Oh, wow, a static method in Python!")
A.foo()
So, your ActionClass could be rewritten as:
class ActionClass(Main):
#staticmethod
def do_action:
app.u.lineEdit.setText("test")
ans then you can use it like this:
if i == self.u.tabs.indexOf(self.u.tabFirst): ActionClass.do_action()
The code is along the lines of this:
class Solver(QDialog):
def __init__(self, parent=None):
blabla
def solver(self):
return qlineedit1.text()
class access(QMainWindow):
prda = Solver().solver()
print prda
The problem is that prda is an empty string. If i put "print qlineedit1.text()" in the Solver class, the text is displayed as it should be. However, when "transferred" to a different class, the string is empty. The weirdest part that it is there - if I do type(prda), I get QString type output.
So, how would I get prda to assume the value of qlineedit1.text() ? I was thinking of writing the text to file in Solver class, and then reading it from access class, but there has to be another solution. By the way, the Solver class and the access class are two dialogs.
Help?
Since next code works as expected, all i can think out without seeing more of your code is that your qlineedit1 is empty.
from PyQt4 import QtGui
class Solver(QtGui.QDialog):
def __init__(self, parent=None):
print "in Solver init"
def solver(self):
return "in solver() method"
class access(QtGui.QMainWindow):
prda = Solver()
print prda.solver()
#this will work too:
#prda = Solver().solver()
#print prda
if __name__ == '__main__':
import sys
app = QtGui.QApplication(sys.argv)
acc=access()
acc.show()
sys.exit(app.exec_())