eric: comparison eric6/Project/Project.py

-:fb0ef164f536
+:698ae46f40a4
 import shutil
 import glob
 import fnmatch
 import copy
 import zipfile
+import contextlib
 from PyQt5.QtCore import (
 pyqtSlot, QFile, QFileInfo, pyqtSignal, QCryptographicHash, QIODevice,
 QByteArray, QObject, QProcess
 )
 Constructor
 @param parent parent widget (usually the ui object) (QWidget)
 @param filename optional filename of a project file to open (string)
 """
-super(Project, self).__init__(parent)
+super().__init__(parent)
 self.ui = parent
 self.__progLanguages = [
 "Python3",
 # *.py should always be associated with source files
 for ext in [".py"]:
 if ext not in extensions:
 extensions.append(ext)
 return extensions
-elif language == "Ruby":
-return ['.rb']
-elif language == "JavaScript":
-return ['.js']
-elif language == "Mixed":
-return (Preferences.getPython("Python3Extensions") +
-['.rb', '.js'])
 else:
-return [""]
+return {
+"Ruby": [".rb"],
+"JavaScript": [".js"],
+"Mixed": (
+Preferences.getPython("Python3Extensions") +
+['.rb', '.js']),
+}.get(language, "")
 def getProgrammingLanguages(self):
 """
 Public method to get the programming languages supported by project.
 "makefile": "OTHERS",
 "Makefile": "OTHERS",
 }
 # Sources
-if self.pdata["MIXEDLANGUAGE"]:
+sourceKey = (
-sourceKey = "Mixed"
+"Mixed"
-else:
+if self.pdata["MIXEDLANGUAGE"] else
-sourceKey = self.pdata["PROGLANGUAGE"]
+self.pdata["PROGLANGUAGE"]
+)
 for ext in self.__sourceExtensions(sourceKey):
 self.pdata["FILETYPES"]["*{0}".format(ext)] = "SOURCES"
 # IDL interfaces
 self.pdata["FILETYPES"]["*.idl"] = "INTERFACES"
 "PySide6", "PySide6C"]:
 self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
 self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
 # Project type specific ones
-try:
+with contextlib.suppress(KeyError):
 if self.__fileTypeCallbacks[
 self.pdata["PROJECTTYPE"]] is not None:
 ftypes = self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"]]()
 self.pdata["FILETYPES"].update(ftypes)
-except KeyError:
-pass
 self.setDirty(True)
 def updateFileTypes(self):
 """
 "PySide6", "PySide6C"]:
 if "*.ts" not in self.pdata["FILETYPES"]:
 self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
 if "*.qm" not in self.pdata["FILETYPES"]:
 self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
-try:
+with contextlib.suppress(KeyError):
 if self.__fileTypeCallbacks[
 self.pdata["PROJECTTYPE"]] is not None:
 ftypes = self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"]]()
 for pattern, ftype in list(ftypes.items()):
 if pattern not in self.pdata["FILETYPES"]:
 self.pdata["FILETYPES"][pattern] = ftype
 self.setDirty(True)
-except KeyError:
-pass
 def __loadRecent(self):
 """
 Private method to load the recently opened project filenames.
 """
 langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
 self.pdata["TRANSLATIONS"].remove(langFile)
 self.__model.removeItem(langFile)
 if qmFile:
-try:
+with contextlib.suppress(ValueError):
 if self.pdata["TRANSLATIONSBINPATH"]:
 qmFile = self.getRelativePath(
 os.path.join(self.pdata["TRANSLATIONSBINPATH"],
 os.path.basename(qmFile)))
 self.pdata["TRANSLATIONS"].remove(qmFile)
 self.__model.removeItem(qmFile)
-except ValueError:
-pass
 self.setDirty(True)
 def deleteLanguageFile(self, langFile):
 """
 Public slot to delete a translation from the project directory.
 @param langFile the translation file to be removed (string)
 """
 try:
-from ThirdParty.Send2Trash.send2trash import send2trash as s2t
+from send2trash import send2trash as s2t
 except ImportError:
 s2t = os.remove
 langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
 @param updateModel flag indicating an update of the model is
 requested (boolean)
 """
 dirty = False
-if os.path.isabs(fn):
+# make it relative to the project root, if it starts with that path
-# make it relative to the project root, if it starts with that path
+# assume relative paths are relative to the project root
-newfn = self.getRelativePath(fn)
+newfn = self.getRelativePath(fn) if os.path.isabs(fn) else fn
-else:
-# assume relative paths are relative to the project root
-newfn = fn
 newdir = os.path.dirname(newfn)
 if isSourceFile:
 filetype = "SOURCES"
 else:
 dn = self.getRelativePath(dn)
 for entry in self.pdata["OTHERS"][:]:
 if entry.startswith(dn):
 self.pdata["OTHERS"].remove(entry)
 dirty = True
-if not dn.endswith(os.sep):
+dn2 = dn if dn.endswith(os.sep) else dn + os.sep
-dn2 = dn + os.sep
-else:
-dn2 = dn
 for key in ["SOURCES", "FORMS", "INTERFACES", "PROTOCOLS", "RESOURCES",
 "TRANSLATIONS", ]:
 for entry in self.pdata[key][:]:
 if entry.startswith(dn2):
 self.pdata[key].remove(entry)
 @param fn filename to be deleted from the project
 @return flag indicating success (boolean)
 """
 try:
-from ThirdParty.Send2Trash.send2trash import send2trash as s2t
+from send2trash import send2trash as s2t
 except ImportError:
 s2t = os.remove
 try:
 s2t(os.path.join(self.ppath, fn))
 """
 if not os.path.isabs(dn):
 dn = os.path.join(self.ppath, dn)
 try:
 try:
-from ThirdParty.Send2Trash.send2trash import send2trash
+from send2trash import send2trash
 send2trash(dn)
 except ImportError:
 shutil.rmtree(dn, True)
 except OSError as err:
 E5MessageBox.critical(
 @param fn filename to be checked (string)
 @return flag indicating, if the project contains the file (boolean)
 """
 fn = self.getRelativePath(fn)
-if (
+return (
 fn in self.pdata["SOURCES"] or
 fn in self.pdata["FORMS"] or
 fn in self.pdata["INTERFACES"] or
 fn in self.pdata["PROTOCOLS"] or
 fn in self.pdata["RESOURCES"] or
 fn in self.pdata["OTHERS"]
-):
+)
-return True
-else:
-return False
 def createNewProject(self):
 """
 Public slot to built a new project.
 if fnmatch.fnmatch(filename, pattern):
 return language
 # try project type specific defaults next
 projectType = self.pdata["PROJECTTYPE"]
-try:
+with contextlib.suppress(KeyError):
 if self.__lexerAssociationCallbacks[projectType] is not None:
 return self.__lexerAssociationCallbacks[projectType](filename)
-except KeyError:
-pass
 # return empty string to signal to use the global setting
 return ""
 @pyqtSlot()
 Utilities.getHomeDir(),
 self.tr("Project Files (*.epj);;XML Project Files (*.e4p)"))
 QApplication.processEvents()
-if fn:
+if fn and self.closeProject():
-if self.closeProject():
+with E5OverrideCursor():
+ok = self.__readProject(fn)
+if ok:
+self.opened = True
+if not self.pdata["FILETYPES"]:
+self.initFileTypes()
+else:
+self.updateFileTypes()
+try:
+# create management directory if not present
+self.createProjectManagementDir()
+except OSError:
+E5MessageBox.critical(
+self.ui,
+self.tr("Create project management directory"),
+self.tr(
+"<p>The project directory <b>{0}</b> is not"
+" writable.</p>")
+.format(self.ppath))
+return
+# read a user specific project file
+self.__readUserProperties()
 with E5OverrideCursor():
-ok = self.__readProject(fn)
+oldState = self.isDirty()
-if ok:
+self.vcs = self.initVCS()
-self.opened = True
+if self.vcs is None and self.isDirty() == oldState:
-if not self.pdata["FILETYPES"]:
+# check, if project is version controlled
-self.initFileTypes()
+pluginManager = e5App().getObject("PluginManager")
-else:
+for indicator, vcsData in (
-self.updateFileTypes()
+pluginManager.getVcsSystemIndicators().items()
+):
-try:
+if os.path.exists(
-# create management directory if not present
+os.path.join(self.ppath, indicator)):
-self.createProjectManagementDir()
+if len(vcsData) > 1:
-except OSError:
+vcsList = []
-E5MessageBox.critical(
+for (
-self.ui,
+_vcsSystemStr, vcsSystemDisplay
-self.tr("Create project management directory"),
+) in vcsData:
-self.tr(
+vcsList.append(vcsSystemDisplay)
-"<p>The project directory <b>{0}</b> is not"
+with E5OverridenCursor():
-" writable.</p>")
+res, vcs_ok = QInputDialog.getItem(
-.format(self.ppath))
+None,
-return
+self.tr("New Project"),
+self.tr(
-# read a user specific project file
+"Select Version Control"
-self.__readUserProperties()
+" System"),
+vcsList,
-with E5OverrideCursor():
+0, False)
-oldState = self.isDirty()
+if vcs_ok:
-self.vcs = self.initVCS()
-if self.vcs is None and self.isDirty() == oldState:
-# check, if project is version controlled
-pluginManager = e5App().getObject("PluginManager")
-for indicator, vcsData in (
-pluginManager.getVcsSystemIndicators().items()
-):
-if os.path.exists(
-os.path.join(self.ppath, indicator)):
-if len(vcsData) > 1:
-vcsList = []
 for (
-_vcsSystemStr, vcsSystemDisplay
+vcsSystemStr, vcsSystemDisplay
 ) in vcsData:
-vcsList.append(vcsSystemDisplay)
+if res == vcsSystemDisplay:
-with E5OverridenCursor():
+vcsSystem = vcsSystemStr
-res, vcs_ok = QInputDialog.getItem(
+break
-None,
-self.tr("New Project"),
-self.tr(
-"Select Version Control"
-" System"),
-vcsList,
-0, False)
-if vcs_ok:
-for (
-vcsSystemStr, vcsSystemDisplay
-) in vcsData:
-if res == vcsSystemDisplay:
-vcsSystem = vcsSystemStr
-break
-else:
-vcsSystem = "None"
 else:
 vcsSystem = "None"
 else:
-vcsSystem = vcsData[0][0]
+vcsSystem = "None"
-self.pdata["VCS"] = vcsSystem
+else:
-self.vcs = self.initVCS()
+vcsSystem = vcsData[0][0]
-self.setDirty(True)
+self.pdata["VCS"] = vcsSystem
-if (
+self.vcs = self.initVCS()
-self.vcs is not None and
+self.setDirty(True)
-(self.vcs.vcsRegisteredState(self.ppath) !=
+if (
-self.vcs.canBeCommitted)
+self.vcs is not None and
-):
+(self.vcs.vcsRegisteredState(self.ppath) !=
-self.pdata["VCS"] = 'None'
+self.vcs.canBeCommitted)
-self.vcs = self.initVCS()
+):
-self.closeAct.setEnabled(True)
+self.pdata["VCS"] = 'None'
-self.saveasAct.setEnabled(True)
+self.vcs = self.initVCS()
-self.actGrp2.setEnabled(True)
+self.closeAct.setEnabled(True)
-self.propsAct.setEnabled(True)
+self.saveasAct.setEnabled(True)
-self.userPropsAct.setEnabled(True)
+self.actGrp2.setEnabled(True)
-self.filetypesAct.setEnabled(True)
+self.propsAct.setEnabled(True)
-self.lexersAct.setEnabled(True)
+self.userPropsAct.setEnabled(True)
-self.sessActGrp.setEnabled(True)
+self.filetypesAct.setEnabled(True)
-self.dbgActGrp.setEnabled(True)
+self.lexersAct.setEnabled(True)
-self.menuDebuggerAct.setEnabled(True)
+self.sessActGrp.setEnabled(True)
-self.menuSessionAct.setEnabled(True)
+self.dbgActGrp.setEnabled(True)
-self.menuCheckAct.setEnabled(True)
+self.menuDebuggerAct.setEnabled(True)
-self.menuShowAct.setEnabled(True)
+self.menuSessionAct.setEnabled(True)
-self.menuDiagramAct.setEnabled(True)
+self.menuCheckAct.setEnabled(True)
-self.menuApidocAct.setEnabled(True)
+self.menuShowAct.setEnabled(True)
-self.menuPackagersAct.setEnabled(True)
+self.menuDiagramAct.setEnabled(True)
-self.pluginGrp.setEnabled(
+self.menuApidocAct.setEnabled(True)
-self.pdata["PROJECTTYPE"] in ["E6Plugin"])
+self.menuPackagersAct.setEnabled(True)
-self.addLanguageAct.setEnabled(
+self.pluginGrp.setEnabled(
-bool(self.pdata["TRANSLATIONPATTERN"]))
+self.pdata["PROJECTTYPE"] in ["E6Plugin"])
-self.makeGrp.setEnabled(
+self.addLanguageAct.setEnabled(
-self.pdata["MAKEPARAMS"]["MakeEnabled"])
+bool(self.pdata["TRANSLATIONPATTERN"]))
-self.menuMakeAct.setEnabled(
+self.makeGrp.setEnabled(
 self.pdata["MAKEPARAMS"]["MakeEnabled"])
+self.menuMakeAct.setEnabled(
-# open a project debugger properties file being quiet
+self.pdata["MAKEPARAMS"]["MakeEnabled"])
-# about errors
-if Preferences.getProject("AutoLoadDbgProperties"):
-self.__readDebugProperties(True)
-self.__model.projectOpened()
-self.projectOpenedHooks.emit()
-self.projectOpened.emit()
-if Preferences.getProject("SearchNewFiles"):
+# open a project debugger properties file being quiet
-self.__doSearchNewFiles()
+# about errors
+if Preferences.getProject("AutoLoadDbgProperties"):
+self.__readDebugProperties(True)
-# read a project tasks file
+self.__model.projectOpened()
-self.__readTasks()
+self.projectOpenedHooks.emit()
-self.ui.taskViewer.setProjectOpen(True)
+self.projectOpened.emit()
-# rescan project tasks
-if Preferences.getProject("TasksProjectRescanOnOpen"):
+if Preferences.getProject("SearchNewFiles"):
-e5App().getObject("TaskViewer"
+self.__doSearchNewFiles()
-).regenerateProjectTasks(quiet=True)
+# read a project tasks file
+self.__readTasks()
+self.ui.taskViewer.setProjectOpen(True)
+# rescan project tasks
+if Preferences.getProject("TasksProjectRescanOnOpen"):
+e5App().getObject("TaskViewer"
+).regenerateProjectTasks(quiet=True)
+if restoreSession:
+# open the main script
+if self.pdata["MAINSCRIPT"]:
+if not os.path.isabs(self.pdata["MAINSCRIPT"]):
+ms = os.path.join(
+self.ppath, self.pdata["MAINSCRIPT"])
+else:
+ms = self.pdata["MAINSCRIPT"]
+self.sourceFile.emit(ms)
-if restoreSession:
+# open a project session file being quiet about errors
-# open the main script
+if reopen:
-if self.pdata["MAINSCRIPT"]:
+self.__readSession(quiet=True, indicator="_tmp")
-if not os.path.isabs(self.pdata["MAINSCRIPT"]):
+elif Preferences.getProject("AutoLoadSession"):
-ms = os.path.join(
+self.__readSession(quiet=True)
-self.ppath, self.pdata["MAINSCRIPT"])
-else:
+# start the VCS monitor thread
-ms = self.pdata["MAINSCRIPT"]
+if self.vcs is not None:
-self.sourceFile.emit(ms)
+self.vcs.startStatusMonitor(self)
+self.vcs.vcsStatusMonitorData.connect(
-# open a project session file being quiet about errors
+self.__model.changeVCSStates)
-if reopen:
+self.vcs.vcsStatusMonitorStatus.connect(
-self.__readSession(quiet=True, indicator="_tmp")
+self.__statusMonitorStatus)
-elif Preferences.getProject("AutoLoadSession"):
+self.vcs.vcsStatusMonitorInfo.connect(
-self.__readSession(quiet=True)
+self.vcsStatusMonitorInfo)
+self.vcs.vcsStatusChanged.connect(
-# start the VCS monitor thread
+self.__vcsStatusChanged)
-if self.vcs is not None:
-self.vcs.startStatusMonitor(self)
-self.vcs.vcsStatusMonitorData.connect(
-self.__model.changeVCSStates)
-self.vcs.vcsStatusMonitorStatus.connect(
-self.__statusMonitorStatus)
-self.vcs.vcsStatusMonitorInfo.connect(
-self.vcsStatusMonitorInfo)
-self.vcs.vcsStatusChanged.connect(
-self.__vcsStatusChanged)
 def reopenProject(self):
 """
 Public slot to reopen the current project.
 """
 Public slot to save the current project to a different file.
 @return flag indicating success (boolean)
 """
 defaultFilter = self.tr("Project Files (*.epj)")
-if self.ppath:
+defaultPath = (
-defaultPath = self.ppath
+self.ppath
-else:
+if self.ppath else
-defaultPath = (
+(Preferences.getMultiProject("Workspace") or
-Preferences.getMultiProject("Workspace") or
+Utilities.getHomeDir())
-Utilities.getHomeDir()
+)
-)
 fn, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
 self.parent(),
 self.tr("Save project as"),
 defaultPath,
 self.tr("Project Files (*.epj);;"
 programming language.
 @return default extension (including the dot) (string)
 """
 lang = self.pdata["PROGLANGUAGE"]
-if lang == "":
+if lang in ("", "Python"):
-lang = "Python3"
-elif lang == "Python":
 lang = "Python3"
 return self.__sourceExtensions(lang)[0]
 def getProjectPath(self):
 """
 def startswithProjectPath(self, path):
 """
 Public method to check, if a path starts with the project path.
-@param path path to be checked (string)
+@param path path to be checked
+@type str
 @return flag indicating that the path starts with the project path
-(boolean)
+@rtype bool
 """
-if self.ppath:
+return (
-if path == self.ppath:
+bool(self.ppath) and
-return True
+(path == self.ppath or
-elif (
+Utilities.normcasepath(Utilities.toNativeSeparators(path))
-Utilities.normcasepath(Utilities.toNativeSeparators(path))
+.startswith(Utilities.normcasepath(
-.startswith(Utilities.normcasepath(
+Utilities.toNativeSeparators(self.ppath + "/")))
-Utilities.toNativeSeparators(self.ppath + "/")))
+)
-):
+)
-return True
-else:
-return False
-else:
-return False
 def getProjectFile(self):
 """
 Public method to get the path of the project file.
 @return path of the project file (string)
 @return flag indicating membership
 @rtype bool
 """
 newfn = os.path.abspath(fn)
 newfn = self.getRelativePath(newfn)
-for group in ["SOURCES", "FORMS", "INTERFACES", "PROTOCOLS",
+return any(
-"RESOURCES", "TRANSLATIONS", "OTHERS"]:
+newfn in self.pdata[group]
-if newfn in self.pdata[group]:
+for group in [
-return True
+"SOURCES", "FORMS", "INTERFACES", "PROTOCOLS", "RESOURCES",
-return False
+"TRANSLATIONS", "OTHERS"
+]
+)
 def isProjectFile(self, fn):
 """
 Public method used to check, if the passed in filename belongs to the
 project.
 @param fn filename to be checked (string)
 @return flag indicating membership (boolean)
 """
-for group in ["SOURCES", "FORMS", "INTERFACES", "PROTOCOLS",
+return any(
-"RESOURCES", "TRANSLATIONS", "OTHERS"]:
+self.__checkProjectFileGroup(fn, group)
-if self.__checkProjectFileGroup(fn, group):
+for group in [
-return True
+"SOURCES", "FORMS", "INTERFACES", "PROTOCOLS", "RESOURCES",
+"TRANSLATIONS", "OTHERS"
-return False
+]
+)
 def __checkProjectFileGroup(self, fn, group):
 """
 Private method to check, if a file is in a specific file group of the
 project.
 @param group group to check (string)
 @return flag indicating membership (boolean)
 """
 newfn = os.path.abspath(fn)
 newfn = self.getRelativePath(newfn)
-if newfn in self.pdata[group]:
+if (
+newfn in self.pdata[group] or
+(group == "OTHERS" and
+any(newfn.startswith(entry) for entry in self.pdata[group]))
+):
 return True
-elif group == "OTHERS":
-for entry in self.pdata[group]:
-if newfn.startswith(entry):
-return True
 if Utilities.isWindowsPlatform():
 # try the above case-insensitive
 newfn = newfn.lower()
-for entry in self.pdata[group]:
+if any(entry.lower() == newfn for entry in self.pdata[group]):
-if entry.lower() == newfn:
+return True
-return True
+elif (
-elif group == "OTHERS":
+group == "OTHERS" and
-for entry in self.pdata[group]:
+any(newfn.startswith(entry.lower())
-if newfn.startswith(entry.lower()):
+for entry in self.pdata[group])
-return True
+):
+return True
 return False
 def isProjectSource(self, fn):
 """
 """
 self.__loadRecent()
 self.recentMenu.clear()
-idx = 1
+for idx, rp in enumerate(self.recent, start=1):
-for rp in self.recent:
+formatStr = '&{0:d}. {1}' if idx < 10 else '{0:d}. {1}'
-if idx < 10:
-formatStr = '&{0:d}. {1}'
-else:
-formatStr = '{0:d}. {1}'
 act = self.recentMenu.addAction(
 formatStr.format(
 idx,
 Utilities.compactPath(rp, self.ui.maxMenuFilePathLen)))
 act.setData(rp)
 act.setEnabled(QFileInfo(rp).exists())
-idx += 1
 self.recentMenu.addSeparator()
 self.recentMenu.addAction(self.tr('&Clear'), self.clearRecent)
 def __openRecent(self, act):
 curpath = os.path.join(self.ppath, directory)
 try:
 newSources = os.listdir(curpath)
 except OSError:
 newSources = []
-if self.pdata["TRANSLATIONPATTERN"]:
+pattern = (
-pattern = (
+self.pdata["TRANSLATIONPATTERN"].replace("%language%", "*")
-self.pdata["TRANSLATIONPATTERN"]
+if self.pdata["TRANSLATIONPATTERN"] else
-.replace("%language%", "*")
+"*.ts"
 )
-else:
-pattern = "*.ts"
 binpattern = self.__binaryTranslationFile(pattern)
 for ns in newSources:
 # ignore hidden files and directories
 if ns.startswith('.'):
 continue
 continue
 # set fn to project relative name
 # then reset ns to fully qualified name for insertion,
 # possibly.
-if directory == "":
+fn = os.path.join(directory, ns) if directory else ns
-fn = ns
-else:
-fn = os.path.join(directory, ns)
 ns = os.path.abspath(os.path.join(curpath, ns))
 # do not bother with dirs here...
 if os.path.isdir(ns):
 if recursiveSearch:
 (filetype == "PROTOCOLS" and
 fn not in self.pdata["PROTOCOLS"]) or
 (filetype == "RESOURCES" and
 fn not in self.pdata["RESOURCES"]) or
 (filetype == "OTHERS" and
-fn not in self.pdata["OTHERS"])
+fn not in self.pdata["OTHERS"]) or
+(filetype == "TRANSLATIONS" and
+fn not in self.pdata["TRANSLATIONS"] and
+(fnmatch.fnmatch(ns, pattern) or
+fnmatch.fnmatch(ns, binpattern)))
 ):
 if autoInclude and AI:
 self.appendFile(ns)
 else:
 newFiles.append(ns)
-elif (
-filetype == "TRANSLATIONS" and
-fn not in self.pdata["TRANSLATIONS"]
-):
-if (
-fnmatch.fnmatch(ns, pattern) or
-fnmatch.fnmatch(ns, binpattern)
-):
-if autoInclude and AI:
-self.appendFile(ns)
-else:
-newFiles.append(ns)
 # if autoInclude is set there is no more work left
 if (autoInclude and AI):
 return
 Public method to remove actions from the list of actions.
 @param actions list of actions (list of E5Action)
 """
 for act in actions:
-try:
+with contextlib.suppress(ValueError):
 self.actions.remove(act)
-except ValueError:
-pass
 def getMenu(self, menuName):
 """
 Public method to get a reference to the main menu or a submenu.
 if self.pdata["VCS"] and self.pdata["VCS"] != 'None':
 vcsSystem = self.pdata["VCS"]
 else:
 forProject = False
-if forProject and self.pdata["VCS"] and self.pdata["VCS"] != 'None':
+if (
-if (
+forProject and
-self.pudata["VCSOVERRIDE"] and
+self.pdata["VCS"] and
-not nooverride
+self.pdata["VCS"] != 'None' and
-):
+self.pudata["VCSOVERRIDE"] and
-vcsSystem = self.pudata["VCSOVERRIDE"]
+not nooverride
-override = True
+):
+vcsSystem = self.pudata["VCSOVERRIDE"]
+override = True
 if vcsSystem is not None:
 import VCS
 try:
 vcs = VCS.factory(vcsSystem)
 vcs.vcsInitConfig(self)
 if vcs and forProject:
 # set the vcs options
 if vcs.vcsSupportCommandOptions():
-try:
+with contextlib.suppress(LookupError):
 vcsopt = copy.deepcopy(self.pdata["VCSOPTIONS"])
 vcs.vcsSetOptions(vcsopt)
-except LookupError:
-pass
 # set vcs specific data
-try:
+with contextlib.suppress(LookupError):
 vcsother = copy.deepcopy(self.pdata["VCSOTHERDATA"])
 vcs.vcsSetOtherData(vcsother)
-except LookupError:
-pass
 if forProject:
 if vcs is None:
 import VCS
 self.vcsProjectHelper = VCS.getBasicHelper(self)
 " ",
 ]
 # write the file
 try:
-if self.pdata["EOL"] == 0:
+newline = None if self.pdata["EOL"] == 0 else self.getEolString()
-newline = None
-else:
-newline = self.getEolString()
 with open(pkglist, "w", encoding="utf-8",
 newline=newline) as pkglistFile:
 pkglistFile.write("\n".join(header) + "\n")
 pkglistFile.write(
 "\n".join([Utilities.fromNativeSeparators(f)
 progress = E5ProgressDialog(
 self.tr("Creating plugin archives..."), self.tr("Abort"),
 0, len(selectedLists), self.tr("%v/%m Archives"))
 progress.setMinimumDuration(0)
 progress.setWindowTitle(self.tr("Create Plugin Archives"))
-count = 0
 errors = 0
-for pkglist in selectedLists:
+for count, pkglist in enumerate(selectedLists):
 progress.setValue(count)
 if progress.wasCanceled():
 break
 try:
 self.tr(
 """<p>The file <b>{0}</b> could not be read.</p>"""
 """<p>Reason: {1}</p>""").format(
 os.path.basename(pkglist), str(why)))
 errors += 1
-count += 1
 continue
 lines = names.splitlines()
 archiveName = ""
 archiveVersion = ""
 """<p>The file <b>{0}</b> is not ready yet."""
 """</p><p>Please rework it and delete the"""
 """'; initial_list' line of the header."""
 """</p>""").format(os.path.basename(pkglist)))
 errors += 1
-count += 1
 listOK = False
 break
 elif line.strip():
 names.append(line.strip())
 if not listOK:
 continue
 names = sorted(names)
-if archiveName:
+archive = (
-archive = os.path.join(self.ppath, archiveName)
+os.path.join(self.ppath, archiveName)
-else:
+if archiveName else
-archive = os.path.join(
+os.path.join(self.ppath,
-self.ppath,
+self.pdata["MAINSCRIPT"].replace(".py", ".zip"))
-self.pdata["MAINSCRIPT"].replace(".py", ".zip"))
+)
 try:
 archiveFile = zipfile.ZipFile(archive, "w")
 except OSError as why:
 E5MessageBox.critical(
 self.ui,
 self.tr(
 """<p>The eric plugin archive file <b>{0}</b>"""
 """ could not be created.</p>"""
 """<p>Reason: {1}</p>""").format(archive, str(why)))
 errors += 1
-count += 1
 continue
 for name in names:
 if name:
 try:
 archiveFile.writestr("VERSION", version.encode("utf-8"))
 archiveFile.close()
 if archive not in self.pdata["OTHERS"]:
 self.appendFile(archive)
-count += 1
 progress.setValue(len(selectedLists))
 if errors:
 self.ui.showNotification(
 UI.PixmapCache.getPixmap("pluginArchive48"),
 self.tr("Create Plugin Archive"),
 self.tr("<p>The eric plugin archive files were "
 "created with some errors.</p>"),
-kind=NotificationTypes.Critical,
+kind=NotificationTypes.CRITICAL,
 timeout=0)
 else:
 self.ui.showNotification(
 UI.PixmapCache.getPixmap("pluginArchive48"),
 self.tr("Create Plugin Archive"),
 Private method to create dir entries in the zip file.
 @param path name of the directory entry to create (string)
 @param zipFile open ZipFile object (zipfile.ZipFile)
 """
-if path == "" or path == "/" or path == "\\":
+if path in ("", "/", "\\"):
 return
 if not path.endswith("/") and not path.endswith("\\"):
 path = "{0}/".format(path)
 not self.pdata["MAKEPARAMS"]["MakeEnabled"] or
 self.__makeProcess is not None
 ):
 return
-if self.pdata["MAKEPARAMS"]["MakeExecutable"]:
+prog = (
-prog = self.pdata["MAKEPARAMS"]["MakeExecutable"]
+self.pdata["MAKEPARAMS"]["MakeExecutable"]
-else:
+if self.pdata["MAKEPARAMS"]["MakeExecutable"] else
-prog = Project.DefaultMake
+Project.DefaultMake
+)
 args = []
 if self.pdata["MAKEPARAMS"]["MakeParameters"]:
 args.extend(Utilities.parseOptionString(
 self.pdata["MAKEPARAMS"]["MakeParameters"]))
 self.ui.showNotification(
 UI.PixmapCache.getPixmap("makefile48"),
 title,
 message,
-kind=NotificationTypes.Warning,
+kind=NotificationTypes.WARNING,
 timeout=0)
 elif exitCode > 1:
 E5MessageBox.critical(
 self.ui,
 self.tr("Execute Make"),

Mercurial Repositories > eric / file comparison

comparison: eric6/Project/Project.py

eric6/Project/Project.py