Discussion :

[hizoka]

Bonsoir,

je rencontre un soucis depuis un bon moment, en effet très souvent, lorsque je ferme mon logiciel via un QPushButton qui lance un self.close, j'ai le droit à un Erreur de segmentation (core dumped).

j'ai vu qu'en utilisant setAttribute(Qt.WA_DeleteOnClose) ça réglait le souci... enfin presque...

je rencontre encore le soucis si j'utilise des QMessageBox ou autre fenêtre comme QInputDialog qui sont suivis d'un self.close().

j'ai essayé de reproduire le problème en repartant à 0 mais je ne suis pas arrivé à grand chose...

Mais ce qui m'interpelle le plus, c'est que j'arrive à contourner le problème en donnant le focus au bouton (via un clic droit ou en le définissant comme bouton par défaut).

En faisant ainsi, je n'ai JAMAIS de core dumped...

Du coup je ne pige pas du tout le problème...

J'ai essayé de reproduire le bug avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
 
class Fenetre(QWidget):
    def __init__(self, parent=None):
        super(Fenetre, self).__init__(parent)
 
        Window = QMessageBox(3, QCoreApplication.translate("main", "Tesseract langs error"), QCoreApplication.translate("main", "The subtitle language is not avaible in Tesseract list langs:\n{}"), QMessageBox.Close, self, Qt.WindowSystemMenuHint)
        Button = QPushButton(QIcon.fromTheme("preferences-desktop-locale", QIcon(":/img/preferences-desktop-locale.png")), QCoreApplication.translate("main", "Use another language"), Window)
        Window.addButton(Button, QMessageBox.YesRole) # Ajout du bouton
        Window.setDefaultButton(Button) # Bouton par défaut
        Window.exec() # Message d'information
 
        # Arret de la fonction
        self.close()
 
 
    def closeEvent(self, event):
        exit(0)
 
 
if __name__ == "__main__":
    app = QApplication(sys.argv)
    fen = Fenetre()
    fen.setAttribute(Qt.WA_DeleteOnClose)
    sys.exit(app.exec_())

mais je préfère joindre mon vrai fichier.

Le code de la fenêtre sera ligne 115, j'ai virer les différents tests pour ne pas que ça vous bloque.
Il suffit d'annuler l'une des 2 fenêtres qui se suivent.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

./TesseractQt.py -l "caca" FichierBidon FichierBidon

Pour info ça me le fait sur différents logiciels, donc je suis surement passé à coté de quelque chose.
Et jamais de problème via la croix de la fenêtre ou via un menu et un triggered.

J’espère avoir été clair... merci à vous d'avance !

[VinsS]

Salut Hizoka,

Le message "Erreur de segmentation (core dumped)" après fermeture est assez courant, il s'explique par le fait que la destruction d'objets Qt côté C++ et la suppression de leur référence par le garbage collector de Python sont deux choses qui s'exécutent dans un ordre non prédictible.

Exemple, lorsque tu cliques sur le bouton, closeEvent est appelé parce que tu l'y as connecté mais aussi des choses comme paintEvent et plein d'autres trucs insoupçonnés.

En forçant Qt à terminer son travail avant de supprimer-fermer-détruire quoique ce soit le message ne devrait plus apparaître.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
    def closeEvent(self, e):
        QtCore.QCoreApplication.processEvents()
        sys.exit() # ou dialog.accept() ou autre ...

[tyrtamos]

Bonjour,

A priori, je ne vois aucune raison d'utiliser le "exit()" dans le closeEvent, et il est possible que ce soit lui qui pose problème.

Voilà comment je fais:

- j'ai en général un bouton "Quitter" qui lance une méthode "quitter", et qui représente la manière normale de fermer la fenêtre (et donc le programme si c'est la fenêtre principale). Cette méthode fait ce qui doit être fait, par exemple enregistrer des données, etc... et se termine par un "self.close()" qui suffit à lui seul pour fermer la fenêtre.

- la méthode closeEvent, n'est pas indispensable, mais elle peut être utile si on veut faire quelque chose de plus quand l'utilisateur ferme la fenêtre en cliquant sur sa croix de fermeture ou par son menu système, et donc sans passer par le "self.close()". Par exemple, on peut arrêter de force un processus QProcess encore en cours d'exécution. Comme closeEvent est une méthode de QWidget, il s'agit d'une surcharge. Et le self.close() de la méthode quitter, lance lui-aussi closeEvent.

Grâce à la surcharge de cette méthode, on peut accepter (event.accept()) ou refuser (event.ignore()) la fermeture. L'acceptation est par défaut.

Lors d'une acceptation de cette fermeture, la fenêtre disparait de l'affichage. Si en plus on a lancé la fenêtre avec setAttribute(QtCore.Qt.WA_DeleteOnClose), cette fenêtre est détruite. Et la boucle principale de traitement des évènements qui est le "app.exec_()" se termine alors en passant sa valeur de fin à sys.exit().

Voilà un petit code de test qui fait ça. Pour montrer cette mécanique, j'ai mis une question finale du genre "vous êtes sûr?".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3
 
import sys
from PyQt5 import (QtWidgets, QtCore)
 
#############################################################################
class Fenetre(QtWidgets.QWidget):
 
    def __init__(self, parent=None):
        super().__init__(parent)
        self.resize(200, 100)
 
        self.boutonquitter = QtWidgets.QPushButton("Quitter", self)
        self.boutonquitter.clicked.connect(self.quitter)
 
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.boutonquitter, 0, 0)
        self.setLayout(posit)
 
    @QtCore.pyqtSlot()
    def quitter(self):
        """fermeture normale de la fenêtre
        """
        # sauvegarder ce qui doit l'être
        # ...
        # et fermer la fenêtre 
        self.close()
 
    def closeEvent(self, event):
        """appelé lors de la fermeture de la fenêtre
           quelque soit la méthode utilisée
        """
        reponse = QtWidgets.QMessageBox.question(self,
                    "Demande d'arrêt", 
                    "Vous êtes sûr de vouloir arrêter le programme?", 
                    buttons = QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No, 
                    defaultButton = QtWidgets.QMessageBox.NoButton)
 
        if reponse == QtWidgets.QMessageBox.Yes:
            event.accept() # accepte la fermeture
        else:
            event.ignore() # refuse la fermeture
 
#############################################################################
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fen = Fenetre()
    fen.setAttribute(QtCore.Qt.WA_DeleteOnClose)
    fen.show()
    sys.exit(app.exec_())

[hizoka]

Vins => QCoreApplication.processEvents() ne change rien chez moi, j'en ai mis à plusieurs endroits histoire d'être sûr mais idem.
merci pour l'explications déjà
mais j'ai du mal à piger qu'il y est une si grande différence dans les traitements si je prends le focus sur le bouton avant (même en laissant appuyer dessus 1s) je n'ai plus aucun problème...
y a moyen de savoir le travail qu'il lui reste à faire justement ?


tyrtamos => C'est comme ça que je fais déjà sur mes gros logiciels.
et j'ai testé justement sans la fonction close mais avec une fonction simple, c'est pareil

dans le cas présent, c'est un code plus que bancal et il a besoin de l'exit :p


J'ai testé donc en passant par d'autres fonctions, en lui demandant d'attendre, en ne mettant pas de bouton maison dedans...

pour le moment la seule façon que j'ai trouvé pour détourner le problème, c'est de définir le bouton close par défaut... mais j'aime pas trop le principe pour le coup...
et c'est pas top, car si on change de focus avant de cliquer dessus, pouf ! ça recommence


Merci pour vos aides, si vous avez une autre idée, je suis preneur

Bon dimanche à vous.

arf la doc qt n'est plus accessible en plus...
http://doc.qt.io/qt-5/classes.html




EDIT : y a un truc que je pige pas...
dans mon petit soft, si je lance la fonction Fermeture qui affiche des print et fait un self.close() (sans fonction closeEvent), le logiciel n'est pas fermé...

[hizoka]

Je relance le sujet au cas où...

j'ai fait d'autres tests comme mettre l'affichage de la fenêtre dans un QThread en me disant que ça laisserait peut être plus de temps mais nope... pas de changement...

[tyrtamos]

Bonjour,

j'ai fait d'autres tests comme mettre l'affichage de la fenêtre dans un QThread en me disant que ça laisserait peut être plus de temps mais nope... pas de changement...

Je continue à penser que tu as tort de terminer ton programme avec "sys.exit()" à cet endroit: il n'est pas seulement inutile, il est nuisible.

Au début du programme, tu demandes à Python de lancer la bibliothèque graphique avec "app = QtWidgets.QApplication(sys.argv)". Cette bibliothèque se met en place avec une certaine logique, et il faut respecter celle-ci jusqu'à son arrêt. Dans ce cadre, le fait de faire un "sys.exit()" en plein milieu du code graphique est d'une grande sauvagerie...

En tout cas, je n'en ai jamais eu besoin: self.close() est suffisant pour arrêter une fenêtre, et si c'est la fenêtre principale, c'est la boucle de traitement des évènements "app.exec_()" qui se terminera proprement en passant son code au dernier sys.exit().

Surcharger closeEvent n'est utile que si on veut faire quelque chose de particulier quand l'utilisateur clique sur la croix pour arrêter la fenêtre (exemples: la question "Vous êtes sûr? ou l'arrêt d'un processus en cours, etc...). Mais à ce stade, la machinerie d'arrêt de la fenêtre est déjà en place, et il n'est pas normal d'avoir besoin de sys.exit() en plus!

Cependant, il m'est déjà arrivé d'avoir des warnings à l'arrêt du programme, parce que j'utilisais des modules de gestion de base de données, et que "je ne faisais pas le ménage" correctement à la fin: il existait alors des ressources que mon code n'avait pas libérées à l'arrêt du programme. J'ai travaillé cette question, et les warnings ont cessé.

A mon avis, c'est dans cette direction qu'il faut chercher: tu as quelque chose d'anormal dans ton code qui t'empêche d'arrêter ton programme correctement!.

Je ne sais pas si ça peut t'aider, mais pendant la mise au point de mes programmes, il y a quelque chose dont j'ai horreur: c'est quand un programme s'arrête brutalement pendant son fonctionnement sans rien dire! Pour qu'il y ait tout de même un message avec un motif d'arrêt en cas d'erreur fatale, j'utilise une fonctionnalité de PyQt5: "QtCore.qInstallMessageHandler(messagederreur)". Et la fonction "messagederreur" contient en gros ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def messagederreur(msgtyp, context, msg):
 
    if msgtyp==QtCore.QtDebugMsg:
        print("Debug PyQt5: %s\n" % (msg,))
 
    elif msgtyp==QtCore.QtWarningMsg:
        print("Warning PyQt5: %s\n" % (msg,))
 
    elif msgtyp==QtCore.QtCriticalMsg or msgtyp==QtCore.QtFatalMsg or msgtyp==QtCore.QtSystemMsg:
        print("Critical/fatal/système PyQt5: %s\n" % (msg,))
        QtWidgets.QMessageBox.critical(None, 
            "Erreur critique PyQt5",
            "Critical/fatal/system: {}\n".format(msg) +\
            "Fichier: {}\n".format(context.file) +\
            "Ligne: {}\n".format(context.line) +\
            "Fonction: {}\n".format(context.function)
            )
    else:
        # message retourné par QtCore.QtInfoMsg créé à partir de Qt 5.5
        print("Info PyQt5: %s\n" % (msg,))

A noter qu'avec ça, on peut en plus désactiver l'affichage de certains warnings lorsqu'ils sont provoqués par un bug de Qt.

[hizoka]

Le truc, c'est que self.close ne fonctionne pas dans le cas présent... il continue quand même à exécuter le code qui suit...

y a un truc qui doit bloquer, mais même en virant tout au max, je trouve pas...
même avec event.accept() ça change rien.


Mais vraiment le truc que je pige pas c'est pourquoi qu'en fonction du bouton de la fenêtre qui avait le focus, ca plante ou non...
Je ne fais que récupérer la valeur de sortie de la fenêtre via les boutons...


Pour les sys.exit(), c'était vraiment pour tester si ça changeait quelque chose mais pas de changement.


Je suis désolé de te demander ça, mais peux tu jeter un oeil au code que j'ai épuré au max, s'il te plait et me dire si tu as le problème, s'il te plait ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

./Qtesseract.py -l fraaaa fichierbidon fichierbidon

Il ne me reste que cette dépendance à terminer pour que mon logiciel soit complet et fonctionnel sans erreur... et je tourne en rond...


merci pour les infos des messages d'erreurs, je vais regarder ça pour l'ajouter à mon soft.


Merci beaucoup pour le temps que vous m'accordez tous !

[tyrtamos]

Je suis désolé de te demander ça, mais peux tu jeter un oeil au code que j'ai épuré au max, s'il te plait et me dire si tu as le problème, s'il te plait ?

Ok je regarde, mais je suis pris cet après-midi: je te répond ce soir si je trouve, ou sinon demain.

Note déjà que self.close() n'a pas d'effet dans la méthode __init__(). Et il semble qu'il y ait un blocage aux environ de Window.exec_() ("exec_" terminé par un blanc souligné!)

Pour le reste, l'importation "attrape tout" avec "*" n'est pas une bonne pratique: je peux te donner une méthode pour supprimer ça.

A+

[hizoka]

Manquerait plus que je t'impose de le faire dans un temps imparti :p

Je prends toute info et bonne pratique que tu veux partager !

[tyrtamos]

Bonjour,

Je fais rarement de l'analyse de code écrit par quelqu'un d'autre parce que c'est très difficile: chacun a ses pratiques, et on met en général longtemps à comprendre. Cependant, je crois avoir compris comment tu dois faire évoluer ton code pour qu'il fonctionne.

=============================================================================
- j'ai commencé par supprimer les importations "attrape-tout" de PyQt5. Ce sont des importations dangereuses, parce que je me suis aperçu que certains noms pouvaient se retrouver à l'identique dans plusieurs modules. Il est d'ailleurs possible que ce soit une partie de tes problèmes. Je te donne la méthode pour traiter tes autres programmes. Il y a 2 fichiers:

=> "pyqt5_classes.py" contient la liste des modules et des classes de PyQt5. Il faudra, bien entendu, faire évoluer par la suite en fonction des nouveautés des versions de PyQt5.

=> "ajoutmodulesqt5.py" est le programme de traitement qui importe le fichier précédent, cherche les noms de classes du fichier source, ajoute le nom de module correspondant (ex: 'QLineEdit' ==> 'QtWidgets.QLineEdit') et écrit dans un nouveau fichier corrigé. Ceci en trouvant par expressions régulières tous les noms qui commencent par 'Q'.

Dans le code de "ajoutmodulesqt5.py", tu mets le nom du fichier source, et le nom du fichier destination (ici "Qtesseract2.py"). Il faut, bien sûr, lire les affichages du traitement pour savoir s'il reste des corrections à faire à la main.

Il faudra de toutes façons changer à la main les lignes d'importation:
"from PyQt5.QtCore import *" ==> "from PyQt5 import QtCore".

=============================================================================
- on ne peut pas utiliser self.close dans __init__: ça ne marche pas. Curieusement, on passe quand même dans closeEvent, mais la fenêtre ne disparait pas: je comprends mieux la sauvagerie du sys.exit()! La méthode __init__ est une méthode particulière qui a d'autres bizarreries, par exemple on ne peut pas utiliser de "return". Il faut donc revoir l'organisation de ton code:

=> s'il existe des conditions qui doivent empêcher l'affichage de la fenêtre, par exemple si les données fournies au lancement sont incorrectes, il faut les traiter AVANT son lancement:

Une fois la bibliothèque Qt lancée avec "app = QtWidgets.QApplication(sys.argv)", on peut utiliser des QMessageBox pour informer l'utilisateur ou lui poser des questions. On utilise alors un parent=None (le self n'existe pas encore!), et on peut si nécessaire arrêter le programme AVANT la boucle de traitement des évènement avec "app.quit()". Et on ne lance la fenêtre que lorsque les conditions favorables sont réunies.

=> pendant la mise au point du programme, on peut neutraliser provisoirement des parties en les entourant par des triples guillemets ou quotes, ou en utilisant des "if" provisoires. On peut d'ailleurs utiliser une variable booléenne globale "debug" pour passer plus vite du code de mise au point au code définitif.

=> une fois la fenêtre lancée et affichée, il est possible de ne laisser à l'utilisateur que la croix de la fenêtre pour arrêter le programme. Dans le cas où tu veux lui donner un moyen plus "civilisé", je t'ai mis un petit menu popup qui se déclenche avec un clic-droit sur la partie grise de la fenêtre, et qui lance la méthode "quitter" qui fait "self.close()". Avec les "print", tu verras comment ça marche: on passe bien par quitter, puis ensuite par closeEvent. Par contre, avec un clic sur la croix de la fenêtre, on ne passe que dans closeEvent. Si tu veux des infos supplémentaires sur ce menu popup: demande!

=============================================================================
Quelques autres remarques:

- Un des principes que j'utilise, c'est que les noms de classes commencent toujours par une majuscule, et les noms de variables par une minuscule. J'ai donc modifié la variable d'instance de ta fenêtre:
"qtesseract = Qtesseract()"
De plus, il ne semblait pas raisonnable de donner le même nom à la classe et sa variable d'instance.

- J'ai ajouté la ligne "qtesseract.show()" qui manquait

- j'ai neutralisé tous les "self.close()" de la méthode __init__.

- j'ai corrigé le "Window.exec()" => "Window.exec_()"

- si tu veux programmer "solide", je te suggère d'utiliser un analyseur de code. En ce qui me concerne, j'utilise "pylint" qui, en plus, donne des recommandations de bonnes pratiques de codage en Python.

Avec tout ça, ton programme corrigé "Qtesseract2.py" fonctionne! J'ai fait le moins de corrections possibles pour que tu t'y retrouves: il te suffira de traiter les conditions de "non-lancement" de la fenêtre avant son lancement effectif.

Bon courage!

[hizoka]

Merci beaucoup pour le temps que tu as pris pour te pencher sur mon problème, je sais que lire les autres est toujours difficile...

L'avantage des importations "attrape-tout" c'est que ça raccourci la longueur des commandes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QtWidgets.QMessageBox.YesRole => QMessageBox.YesRole

mais bon je vais suivre tes conseils et essayer ça.
Merci pour les fichiers.


La fonction __init__ est particulière en effet, je ne connaissais pas ses spécificités.
Merci pour les explications, je vais donc partir sur tout tester en amont.
J'utilise un mode debug dans mon gros soft pour reccup plus d'infos en effet

Pour les moyens de fermetures, j'avais bien saisi le fonctionnement entre la croix, des boutons, le popup...
donc pas de question sur ce point là

De plus, il ne semblait pas raisonnable de donner le même nom à la classe et sa variable d'instance.

J'en ai pris bonne note !

J'ai ajouté la ligne "qtesseract.show()" qui manquait

En fait je ne fais apparaître la fenêtre que dans le corps de la classe vue que son apparition n'est pas obligatoire.

Le problème c'est que j'ai tourné les commandes autour de la fenêtre comme d'habitude alors qu'en fait la fenêtre n'est que secondaire dans ce script là...

j'ai corrigé le "Window.exec()" => "Window.exec_()"

Après recherche exec_ était nécessaire pour python 2 car exec était un mot interdit, ce qui n'est plus le cas dans python3 et de ce fait il ne sert à rien d'utiliser le _ mais pylint3 les veut...


pylint3 a l'air méchant :p il critique beaucoup mais je vais essayer de m'y mettre pour respecter au mieux les règles.


Encore un très grand merci à toi pour ton implication !
je vous tiens au courant une fois le travail fait !

[tyrtamos]

L'avantage des importations "attrape-tout" c'est que ça raccourci la longueur des commandes

A noter qu'en utilisant une partie de mon code, tu peux faire autrement: au lieu de corriger chaque nom de classe, tu peux fabriquer des instructions d'importation plus complètes:

A "QLineEdit" trouvé => on ajoute QLineEdit à "from PyQt5.QtWidgets import (..., ... ,..., QLineEdit, ...), à moins qu'il ne s'y trouve déjà.

Et pylint te permettra de voir si certaines importations deviennent inutiles en fonction de l'évolution de ton code!

pylint3 a l'air méchant :p il critique beaucoup mais je vais essayer de m'y mettre pour respecter au mieux les règles

Il est très configurable, et on peut donc neutraliser beaucoup de messages qui n'apportent rien en fonction de la manière dont on travaille.

Par ailleurs, il lui arrive de rapporter des messages pas très pertinents pour certaines astuces de codage: il ne faut donc pas prendre tout ce qu'il dit au pied de la lettre. Mais c'est une sacré aide pour pousser à une programmation plus solide!

[hizoka]

Je regarderai pour les noms des widgets pour faire comme ça car plus lisible je trouve.

Sinon je viens de tout modifier mais c'est pareil...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
if __name__ == '__main__':
    app = QtWidgets.QApplication(sys.argv)
    app.setApplicationVersion("1.0")
    app.setApplicationName("Qtesseract")
 
    .....
 
    Window = QtWidgets.QMessageBox(3, "Tesseract langs error", "The subtitle language is not avaible in Tesseract list langs:", QtWidgets.QMessageBox.Close, None, QtCore.Qt.WindowSystemMenuHint)
    Button = QtWidgets.QPushButton(QtGui.QIcon.fromTheme("preferences-desktop-locale"), QtCore.QCoreApplication.translate("main", "Use another language"), Window)
    Window.addButton(Button, QtWidgets.QMessageBox.YesRole) # Ajout du bouton
    Window.setDefaultButton(QtWidgets.QMessageBox.Close)
    Window.exec()

la fenêtre n'est toujours pas lancée, elle ne le sera que si on va jusqu'au bout mais là quelque soit ma façon de lui dire stop, il continue...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    if Window.buttonRole(Window.clickedButton()) != 5: app.quit()
    if Window.buttonRole(Window.clickedButton()) != 5: app.exit(0)
    if Window.buttonRole(Window.clickedButton()) != 5: app.exit(1)

il poursuit l’exécution du code...

même avec QtCore.QCoreApplication.processEvents()...

je pige vraiment plus rien moi...

et toujours ce fameux core dumped... arffff... même avec l'import à ta façon...

Une autre idée ?

[tyrtamos]

Je ne comprends pas les arguments que tu as mis à QMessageBox. Si je regarde la doc, j'ai droit à l'un de ces 2 appels (voir http://doc.qt.io/qt-5/qmessagebox.html):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
QMessageBox(QWidget * parent = 0)
QMessageBox(Icon icon, const QString & title, const QString & text, StandardButtons buttons = NoButton, QWidget * parent = 0, Qt::WindowFlags f = Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint)

De ce fait, je ne vois pas ce qu'est le "3".

Essaie de mettre au point ton QMessageBox dans un petit script à part.

[hizoka]

en fait l'icone c'est QtWidgets.QMessageBox.Critical mais ça passe aussi avec 3.

pas de changement de comportement...

EDIT : meme avec une version avec un simple bouton fermer et rien d'autre, ça plante pareil.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
from PyQt5 import QtGui, QtWidgets, QtCore
import sys
 
#############################################################################
if __name__ == '__main__':
    ####################
    ### QtWidgets.QApplication ###
    ####################
    app = QtWidgets.QApplication(sys.argv)
    app.setApplicationVersion("1.0")
    app.setApplicationName("Qtesseract")
 
 
    ## Message d'information
    Window = QtWidgets.QMessageBox(1, "Tesseract langs error", "The subtitle language is not avaible in Tesseract list langs:", QtWidgets.QMessageBox.Close, None, QtCore.Qt.WindowSystemMenuHint).exec() # Message d'information
 
    app.quit()
 
    print("je ne devrais pas être là")
    print("je ne devrais pas être là")
    print("je ne devrais pas être là")
    print("je ne devrais pas être là")
    print("je ne devrais pas être là")

[tyrtamos]

Simplifie! Retire des trucs jusqu'à ce que ça marche, et rajoute-en petit à petit: tu sauras ce qui cloche.

Ajoute des "print" avec des numéros (1, 2, 3, ...) pour pister le déroulement jusqu'au plantage.

Ajoute des try:..except: pour récupérer des messages d'erreur.

Et regarde la doc sur les points où tu n'es pas sûr: il y a des tas de choses intéressantes dans la doc!

Il y a aussi des fois des astuces de codages bien dans les exemples fournis avec PyQt.

Prend du recul: quelquefois, tu peux faire d'une autre façon pour atteindre le même but.

Et redonnes-moi ton fichier actuel qui ne marche pas pour voir si j'aurais une autre idée!

[edit]: je réponds à ton edit: après le app.quit(), tu est sorti de la bibliothèque graphique et tu es de nouveau dans le Python pur: tu peux donc faire sys.exit() pour ne pas aller plus loin!

[hizoka]

arf c'est donc pour ça XD, donc en effet maintenant c'est bon.

il reste toujours ce fameux "core dumped" sniffff

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if __name__ == '__main__':
    app = QtWidgets.QApplication(sys.argv)
 
    Window = QtWidgets.QMessageBox(QtWidgets.QMessageBox.Information, "Tesseract langs error", "The subtitle language is not avaible in Tesseract list langs:", QtWidgets.QMessageBox.Close | QtWidgets.QMessageBox.Yes, None, QtCore.Qt.WindowSystemMenuHint).exec() # Message d'information

Si je clique sur le bouton qui n'a pas le focus, ça me renvoie Erreur de segmentation (core dumped).

difficile de faire plus simple :p

j'essayé de finir le script avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
app.quit()
app.exit()
sys.exit()
rien du tout

mais aucun changement.

Rencontrez vous vous aussi ce core dumped ?


Encore un grand merci pour ton aide !!!!

[tyrtamos]

Je n'ai jamais eu de "core dumped" avec ton code. Mais j'ai eu des plantages au début (arrêt avec freeze de la console). Attention: ça dépend peut-être de l'OS (je travaille sous Windows 10).

Pour un simple message d'information, j'utilise ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
QtWidgets.QMessageBox.information(parent, 
            "titre", 
            "message")

Et à cet endroit, parent=None.

Essaie!

[hizoka]

Un peu plus galere à en avoir (y a qu'un seul bouton qui a le focus) mais ça me le fait aussi...
donc y en aurait pas par chez toi...

[tyrtamos]

Est-ce qu'un code comme ça te pose problème?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import sys
 
from PyQt5 import QtWidgets
 
#############################################################################
if __name__ == '__main__':
 
    app = QtWidgets.QApplication(sys.argv)
 
    QtWidgets.QMessageBox.information(None, 
            "titre", 
            "message")
 
    app.quit()
    sys.exit()

Si oui, tu as un pb d'installation!