cx_freeze Packager: comparison PluginCxFreeze.py

-:0f3a641c5da5
+:7880b294d1d1
 """
 import os
 import platform
-from PyQt5.QtCore import QObject, QTranslator, QCoreApplication, QProcess
+from PyQt6.QtCore import QObject, QTranslator, QCoreApplication, QProcess
-from PyQt5.QtWidgets import QDialog
+from PyQt6.QtWidgets import QDialog
-from E5Gui import E5MessageBox
+from EricWidgets import EricMessageBox
-from E5Gui.E5Action import E5Action
+from EricGui.EricAction import EricAction
-from E5Gui.E5Application import e5App
+from EricWidgets.EricApplication import ericApp
 import Utilities
 # Start-of-Header
 name = "CxFreeze Plugin"
 author = "Detlev Offenbach <detlev@die-offenbachs.de>"
 autoactivate = True
 deactivateable = True
-version = "7.2.0"
+version = "1.0.0"
 className = "CxFreezePlugin"
 packageName = "CxFreeze"
 shortDescription = "Show the CxFreeze dialogs."
 longDescription = (
 """This plugin implements the CxFreeze dialogs."""
 """
 Public method to support the display of some executable info.
 @return dictionary containing the data to query the presence of
 the executable
+@rtype dict
 """
 dataList = []
 data = {
 "programEntry": True,
 "header": QCoreApplication.translate(
 def _findExecutable(majorVersion):
 """
 Restricted function to determine the names of the executable.
-@param majorVersion major python version of the executables (int)
+@param majorVersion major Python version of the executables
-@return names of the executable (list)
+@type int
+@return names of the executable
+@rtype list of str
 """
 # Determine Python Version
 if majorVersion == 3:
 minorVersions = range(10)
 else:
 def _checkProgram():
 """
 Restricted function to check the availability of cxfreeze.
-@return flag indicating availability (boolean)
+@return flag indicating availability
+@rtype bool
 """
 global error, exePy3
 exePy3 = _findExecutable(3)
 if exePy3 == []:
 """
 def __init__(self, ui):
 """
 Constructor
-@param ui reference to the user interface object (UI.UserInterface)
+@param ui reference to the user interface object
+@type UserInterface
 """
 super().__init__(ui)
 self.__ui = ui
 self.__initialize()
 _checkProgram()
 def activate(self):
 """
 Public method to activate this plugin.
-@return tuple of None and activation status (boolean)
+@return tuple of None and activation status
+@rtype tuple of (None, bool)
 """
 global error
 # There is already an error, don't activate
 if error:
 # cxfreeze is only activated if it is available
 if not _checkProgram():
 return None, False
-project = e5App().getObject("Project")
+project = ericApp().getObject("Project")
 menu = project.getMenu("Packagers")
 if menu:
-self.__projectAct = E5Action(
+self.__projectAct = EricAction(
 self.tr('Use cx_freeze'),
 self.tr('Use cx_&freeze'), 0, 0,
 self, 'packagers_cxfreeze')
 self.__projectAct.setStatusTip(
 self.tr('Generate a distribution package using cx_freeze'))
 """ The command is executed in the project path. All"""
 """ files and directories must be given absolute or"""
 """ relative to the project directory.</p>"""
 ))
 self.__projectAct.triggered.connect(self.__cxfreeze)
-project.addE5Actions([self.__projectAct])
+project.addEricActions([self.__projectAct])
 self.__projectSeparator = menu.addSeparator()
 menu.addAction(self.__projectAct)
 project.showMenu.connect(self.__projectShowMenu)
 error = ""
 def deactivate(self):
 """
 Public method to deactivate this plugin.
 """
-menu = e5App().getObject("Project").getMenu("Packagers")
+menu = ericApp().getObject("Project").getMenu("Packagers")
 if menu:
 if self.__projectAct:
 menu.removeAction(self.__projectAct)
-e5App().getObject("Project").removeE5Actions(
+ericApp().getObject("Project").removeEricActions(
 [self.__projectAct])
 if self.__projectSeparator:
 menu.removeAction(self.__projectSeparator)
 self.__initialize()
 def __projectShowMenu(self, menuName, menu):
 """
 Private slot called, when the the project menu or a submenu is
 about to be shown.
-@param menuName name of the menu to be shown (string)
+@param menuName name of the menu to be shown
-@param menu reference to the menu (QMenu)
+@type str
+@param menu reference to the menu
+@type QMenu
 """
 if (
 menuName == "Packagers" and
 self.__projectAct is not None
 ):
 self.__projectAct.setEnabled(
-e5App().getObject("Project").getProjectLanguage() ==
+ericApp().getObject("Project").getProjectLanguage() ==
 "Python3"
 )
 def __loadTranslator(self):
 """
 translation = "cxfreeze_{0}".format(loc)
 translator = QTranslator(None)
 loaded = translator.load(translation, locale_dir)
 if loaded:
 self.__translator = translator
-e5App().installTranslator(self.__translator)
+ericApp().installTranslator(self.__translator)
 else:
 print("Warning: translation file '{0}' could not be"
 " loaded.".format(translation))
 print("Using default.")
 def __cxfreeze(self):
 """
 Private slot to handle the cxfreeze execution.
 """
-project = e5App().getObject("Project")
+project = ericApp().getObject("Project")
 if not project.getMainScript():
 # no main script defined
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.__ui,
 self.tr("cxfreeze"),
 self.tr(
 """There is no main script defined for the current"""
 """ project."""),
-E5MessageBox.StandardButtons(E5MessageBox.Abort))
+EricMessageBox.StandardButtons(EricMessageBox.Abort))
 return
 majorVersionStr = project.getProjectLanguage()
 exe = {"Python3": exePy3}.get(majorVersionStr)
 if exe == []:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.__ui,
 self.tr("cxfreeze"),
 self.tr("""The cxfreeze executable could not be found."""))
 return
 return
 from CxFreeze.CxfreezeConfigDialog import CxfreezeConfigDialog
 parms = project.getData('PACKAGERSPARMS', "CXFREEZE")
 dlg = CxfreezeConfigDialog(project, exe, parms)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 args, parms = dlg.generateParameters()
 project.setData('PACKAGERSPARMS', "CXFREEZE", parms)
 # now do the call
 from CxFreeze.CxfreezeExecDialog import CxfreezeExecDialog
 res = dia.start(args, parms, project.ppath,
 project.getMainScript())
 if res:
 dia.exec()
+def installDependencies(pipInstall):
+"""
+Function to install dependencies of this plug-in.
+@param pipInstall function to be called with a list of package names.
+@type function
+"""
+try:
+import cx_Freeze         # __IGNORE_WARNING__
+except ImportError:
+pipInstall(["cx-Freeze"])
 #
 # eflag: noqa = M801

Mercurial Repositories > cx_freeze Packager / file comparison

comparison: PluginCxFreeze.py

PluginCxFreeze.py