Flask Project: comparison ProjectFlask/FlaskBabelExtension/PyBabelProjectExtension.py

-:7c05cbc8b3e5
+:0ee58185b8df
 import os
 import re
 import contextlib
-from PyQt5.QtCore import pyqtSlot, QObject, QProcess
+from PyQt6.QtCore import pyqtSlot, QObject, QProcess
-from PyQt5.QtWidgets import QDialog, QMenu
+from PyQt6.QtWidgets import QDialog, QMenu
-from E5Gui import E5MessageBox
+from EricWidgets import EricMessageBox
-from E5Gui.E5Application import e5App
+from EricWidgets.EricApplication import ericApp
-from E5Gui.E5Action import E5Action
+from EricGui.EricAction import EricAction
 from .PyBabelCommandDialog import PyBabelCommandDialog
 import Utilities
 super().__init__(parent)
 self.__plugin = plugin
 self.__project = project
-self.__e5project = e5App().getObject("Project")
+self.__ericProject = ericApp().getObject("Project")
 self.__hooksInstalled = False
 def initActions(self):
 """
 Public method to define the flask-babel actions.
 """
 self.actions = []
-self.pybabelConfigAct = E5Action(
+self.pybabelConfigAct = EricAction(
 self.tr('Configure flask-babel'),
 self.tr('&Configure flask-babel'),
 0, 0,
 self, 'flask_config_pybabel')
 self.pybabelConfigAct.setStatusTip(self.tr(
 ))
 self.pybabelConfigAct.triggered.connect(
 self.__configurePyBabel)
 self.actions.append(self.pybabelConfigAct)
-self.pybabelInstallAct = E5Action(
+self.pybabelInstallAct = EricAction(
 self.tr('Install flask-babel'),
 self.tr('&Install flask-babel'),
 0, 0,
 self, 'flask_install_pybabel')
 self.pybabelInstallAct.setStatusTip(self.tr(
 ))
 self.pybabelInstallAct.triggered.connect(
 self.__installFlaskBabel)
 self.actions.append(self.pybabelInstallAct)
-self.pybabelAvailabilityAct = E5Action(
+self.pybabelAvailabilityAct = EricAction(
 self.tr('Check flask-babel Availability'),
 self.tr('Check flask-babel &Availability'),
 0, 0,
 self, 'flask_check_pybabel')
 self.pybabelAvailabilityAct.setStatusTip(self.tr(
 def projectOpenedHooks(self):
 """
 Public method to add our hook methods.
 """
 if self.__project.hasCapability("flask-babel"):
-self.__e5project.projectLanguageAddedByCode.connect(
+self.__ericProject.projectLanguageAddedByCode.connect(
 self.__projectLanguageAdded)
 self.__translationsBrowser = (
-e5App().getObject("ProjectBrowser")
+ericApp().getObject("ProjectBrowser")
 .getProjectBrowser("translations"))
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 "extractMessages", self.extractMessages,
 self.tr("Extract Messages"))
 self.__translationsBrowser.addHookMethodAndMenuEntry(
 def projectClosedHooks(self):
 """
 Public method to remove our hook methods.
 """
 if self.__hooksInstalled:
-self.__e5project.projectLanguageAddedByCode.disconnect(
+self.__ericProject.projectLanguageAddedByCode.disconnect(
 self.__projectLanguageAdded)
 self.__translationsBrowser.removeHookMethod(
 "extractMessages")
 self.__translationsBrowser.removeHookMethod(
 "releaseAll")
 interpreter = self.__project.getVirtualenvInterpreter()
 if interpreter and Utilities.isinpath(interpreter):
 detector = os.path.join(
 os.path.dirname(__file__), "FlaskBabelDetector.py")
 proc = QProcess()
-proc.setProcessChannelMode(QProcess.MergedChannels)
+proc.setProcessChannelMode(
+QProcess.ProcessChannelMode.MergedChannels)
 proc.start(interpreter, [detector])
 finished = proc.waitForFinished(30000)
 if finished and proc.exitCode() == 0:
 return True
 """
 from .PyBabelConfigDialog import PyBabelConfigDialog
 config = self.__project.getData("flask-babel", "")
 dlg = PyBabelConfigDialog(config)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 config = dlg.getConfiguration()
 self.__project.setData("flask-babel", "", config)
-self.__e5project.setTranslationPattern(os.path.join(
+self.__ericProject.setTranslationPattern(os.path.join(
 config["translationsDirectory"], "%language%", "LC_MESSAGES",
 "{0}.po".format(config["domain"])
 ))
-self.__e5project.setDirty(True)
+self.__ericProject.setDirty(True)
-cfgFileName = self.__e5project.getAbsoluteUniversalPath(
+cfgFileName = self.__ericProject.getAbsoluteUniversalPath(
 config["configFile"])
 if not os.path.exists(cfgFileName):
 self.__createBabelCfg(cfgFileName)
 def __ensurePybabelConfigured(self):
 self.__configurePybabel()
 return True
 configFileName = self.__project.getData("flask-babel", "configFile")
 if configFileName:
-cfgFileName = self.__e5project.getAbsoluteUniversalPath(
+cfgFileName = self.__ericProject.getAbsoluteUniversalPath(
 configFileName)
 if os.path.exists(cfgFileName):
 return True
 else:
 return self.__createBabelCfg(cfgFileName)
 "extensions=jinja2.ext.autoescape,jinja2.ext.with_\n")
 )
 try:
 with open(configFile, "w") as f:
 f.write(template.format(app))
-self.__e5project.appendFile(configFile)
+self.__ericProject.appendFile(configFile)
-E5MessageBox.information(
+EricMessageBox.information(
 None,
 self.tr("Generate PyBabel Configuration File"),
 self.tr("""The PyBabel configuration file was created."""
 """ Please edit it to adjust the entries as"""
 """ required.""")
 )
 return True
 except OSError as err:
-E5MessageBox.warning(
+EricMessageBox.warning(
 None,
 self.tr("Generate PyBabel Configuration File"),
 self.tr("""<p>The PyBabel Configuration File could not be"""
 """ generated.</p><p>Reason: {0}</p>""")
 .format(str(err))
 environment.
 """
 venvName = self.__project.getVirtualEnvironment()
 if venvName:
 interpreter = self.__project.getFullCommand("python")
-pip = e5App().getObject("Pip")
+pip = ericApp().getObject("Pip")
 pip.installPackages(["flask-babel"], interpreter=interpreter)
 self.determineCapability()
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr("Install flask-babel"),
 self.tr("The 'flask-babel' extension could not be installed"
 " because no virtual environment has been"
 " configured."))
 msg = (
 self.tr("The 'flask-babel' extension is installed.")
 if self.__project.hasCapability("flask-babel") else
 self.tr("The 'flask-babel' extension is not installed.")
 )
-E5MessageBox.information(
+EricMessageBox.information(
 None,
 self.tr("flask-babel Availability"),
 msg)
 def __getLocale(self, filename):
 @param filename name of the file used for extraction
 @type str
 @return extracted locale
 @rtype str or None
 """
-if self.__e5project.getTranslationPattern():
+if self.__ericProject.getTranslationPattern():
 filename = os.path.splitext(filename)[0] + ".po"
 # On Windows, path typically contains backslashes. This leads
 # to an invalid search pattern '...\(' because the opening bracket
 # will be escaped.
-pattern = self.__e5project.getTranslationPattern()
+pattern = self.__ericProject.getTranslationPattern()
 pattern = os.path.normpath(pattern)
 pattern = pattern.replace("%language%", "(.*?)")
 pattern = pattern.replace('\\', '\\\\')
 match = re.search(pattern, filename)
 if match is not None:
 editor = self.__plugin.getPreferences("TranslationsEditor")
 if poFile.endswith(".po") and editor:
 workdir = self.__project.getApplication()[0]
 started, pid = QProcess.startDetached(editor, [poFile], workdir)
 if not started:
-E5MessageBox.critical(
+EricMessageBox.critical(
 None,
 self.tr('Process Generation Error'),
 self.tr('The translations editor process ({0}) could'
 ' not be started.').format(
 os.path.basename(editor)))
 Public method to extract the messages catalog template file.
 """
 title = self.tr("Extract messages")
 if self.__ensurePybabelConfigured():
 workdir = self.__project.getApplication()[0]
-potFile = self.__e5project.getAbsoluteUniversalPath(
+potFile = self.__ericProject.getAbsoluteUniversalPath(
 self.__project.getData("flask-babel", "catalogFile"))
 with contextlib.suppress(OSError):
 potFilePath = os.path.dirname(potFile)
 os.makedirs(potFilePath)
 args = [
 "-F",
 os.path.relpath(
-self.__e5project.getAbsoluteUniversalPath(
+self.__ericProject.getAbsoluteUniversalPath(
 self.__project.getData("flask-babel", "configFile")),
 workdir
 )
 ]
 if self.__project.getData("flask-babel", "markersList"):
 msgSuccess=self.tr("\nMessages extracted successfully.")
 )
 res = dlg.startCommand("extract", args, workdir)
 if res:
 dlg.exec()
-self.__e5project.appendFile(potFile)
+self.__ericProject.appendFile(potFile)
 def __projectLanguageAdded(self, code):
 """
 Private slot handling the addition of a new language.
 title = self.tr(
 "Initializing message catalog for '{0}'").format(code)
 if self.__ensurePybabelConfigured():
 workdir = self.__project.getApplication()[0]
-langFile = self.__e5project.getAbsoluteUniversalPath(
+langFile = self.__ericProject.getAbsoluteUniversalPath(
-self.__e5project.getTranslationPattern().replace(
+self.__ericProject.getTranslationPattern().replace(
 "%language%", code))
-potFile = self.__e5project.getAbsoluteUniversalPath(
+potFile = self.__ericProject.getAbsoluteUniversalPath(
 self.__project.getData("flask-babel", "catalogFile"))
 args = [
 "--domain={0}".format(
 self.__project.getData("flask-babel", "domain")),
 )
 res = dlg.startCommand("init", args, workdir)
 if res:
 dlg.exec()
-self.__e5project.appendFile(langFile)
+self.__ericProject.appendFile(langFile)
 def compileCatalogs(self, filenames):
 """
 Public method to compile the message catalogs.
 """
 title = self.tr("Compiling message catalogs")
 if self.__ensurePybabelConfigured():
 workdir = self.__project.getApplication()[0]
-translationsDirectory = self.__e5project.getAbsoluteUniversalPath(
+translationsDirectory = (
-self.__project.getData("flask-babel", "translationsDirectory"))
+self.__ericProject.getAbsoluteUniversalPath(
+self.__project.getData(
+"flask-babel", "translationsDirectory")
+)
+)
 args = [
 "--domain={0}".format(
 self.__project.getData("flask-babel", "domain")),
 "--directory={0}".format(
 for entry in os.walk(translationsDirectory):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
 if fullName.endswith('.mo'):
-self.__e5project.appendFile(fullName)
+self.__ericProject.appendFile(fullName)
 def compileSelectedCatalogs(self, filenames):
 """
 Public method to update the message catalogs.
 title = self.tr("Compiling message catalogs")
 locales = {self.__getLocale(f) for f in filenames}
 if len(locales) == 0:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self.__ui,
 title,
 self.tr('No locales detected. Aborting...'))
 return
 if self.__ensurePybabelConfigured():
 workdir = self.__project.getApplication()[0]
-translationsDirectory = self.__e5project.getAbsoluteUniversalPath(
+translationsDirectory = (
-self.__project.getData("flask-babel", "translationsDirectory"))
+self.__ericProject.getAbsoluteUniversalPath(
+self.__project.getData(
+"flask-babel", "translationsDirectory")
+)
+)
 argsList = []
 for loc in locales:
 argsList.append([
 "compile",
 for entry in os.walk(translationsDirectory):
 for fileName in entry[2]:
 fullName = os.path.join(entry[0], fileName)
 if fullName.endswith('.mo'):
-self.__e5project.appendFile(fullName)
+self.__ericProject.appendFile(fullName)
 def updateCatalogs(self, filenames, withObsolete=False):
 """
 Public method to update the message catalogs.
 """
 title = self.tr("Updating message catalogs")
 if self.__ensurePybabelConfigured():
 workdir = self.__project.getApplication()[0]
-translationsDirectory = self.__e5project.getAbsoluteUniversalPath(
+translationsDirectory = (
-self.__project.getData("flask-babel", "translationsDirectory"))
+self.__ericProject.getAbsoluteUniversalPath(
-potFile = self.__e5project.getAbsoluteUniversalPath(
+self.__project.getData(
+"flask-babel", "translationsDirectory")
+)
+)
+potFile = self.__ericProject.getAbsoluteUniversalPath(
 self.__project.getData("flask-babel", "catalogFile"))
 args = [
 "--domain={0}".format(
 self.__project.getData("flask-babel", "domain")),
 title = self.tr("Updating message catalogs")
 locales = {self.__getLocale(f) for f in filenames}
 if len(locales) == 0:
-E5MessageBox.warning(
+EricMessageBox.warning(
 self.__ui,
 title,
 self.tr('No locales detected. Aborting...'))
 return
 if self.__ensurePybabelConfigured():
 workdir = self.__project.getApplication()[0]
-translationsDirectory = self.__e5project.getAbsoluteUniversalPath(
+translationsDirectory = (
-self.__project.getData("flask-babel", "translationsDirectory"))
+self.__ericProject.getAbsoluteUniversalPath(
-potFile = self.__e5project.getAbsoluteUniversalPath(
+self.__project.getData(
+"flask-babel", "translationsDirectory")
+)
+)
+potFile = self.__ericProject.getAbsoluteUniversalPath(
 self.__project.getData("flask-babel", "catalogFile"))
 argsList = []
 for loc in locales:
 args = [
 "update",

Mercurial Repositories > Flask Project / file comparison

comparison: ProjectFlask/FlaskBabelExtension/PyBabelProjectExtension.py

ProjectFlask/FlaskBabelExtension/PyBabelProjectExtension.py