eric: comparison Project/Project.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 from E5Gui.E5Action import E5Action, createActionGroup
 import Preferences
 import Utilities
 class Project(QObject):
 """
 Class implementing the project management functionality.
 OTHERS project data area
 @signal projectAboutToBeCreated() emitted just before the project will be created
 @signal newProjectHooks() emitted after a new project was generated but before
 the newProject() signal is sent
 @signal newProject() emitted after a new project was generated
 @signal sourceFile(str) emitted after a project file was read to
 open the main script
 @signal projectOpenedHooks() emitted after a project file was read but before the
 projectOpened() signal is sent
 @signal projectOpened() emitted after a project file was read
 @signal projectClosedHooks() emitted after a project file was closed but before the
 showMenu = pyqtSignal(str, QMenu)
 lexerAssociationsChanged = pyqtSignal()
 keynames = [
 "PROGLANGUAGE", "MIXEDLANGUAGE", "PROJECTTYPE",
 "SPELLLANGUAGE", "SPELLWORDS", "SPELLEXCLUDES",
 "DESCRIPTION", "VERSION", "HASH",
 "AUTHOR", "EMAIL",
 "SOURCES", "FORMS", "RESOURCES",
 "TRANSLATIONS", "TRANSLATIONPATTERN", "TRANSLATIONSBINPATH",
 "TRANSLATIONEXCEPTIONS",
 "MAINSCRIPT", "EOL",
 "VCS", "VCSOPTIONS", "VCSOTHERDATA",
 "OTHERS", "INTERFACES",
 "FILETYPES", "LEXERASSOCS",
 "PROJECTTYPESPECIFICDATA",
 "DOCUMENTATIONPARMS",
 "PACKAGERSPARMS",
 "CHECKERSPARMS",
 "OTHERTOOLSPARMS",
 ]
 dbgKeynames = [
 "INTERPRETER", "DEBUGCLIENT",
 "ENVIRONMENTOVERRIDE", "ENVIRONMENTSTRING",
 "VCSOVERRIDE", "VCSSTATUSMONITORINTERVAL",
 ]
 eols = [os.linesep, "\n", "\r", "\r\n"]
-def __init__(self, parent = None, filename = None):
+def __init__(self, parent=None, filename=None):
 """
 Constructor
 @param parent parent widget (usually the ui object) (QWidget)
 @param filename optional filename of a project file to open (string)
 QObject.__init__(self, parent)
 self.ui = parent
 self.sourceExtensions = {
-"Python2"  : Preferences.getPython("PythonExtensions"),
+"Python2": Preferences.getPython("PythonExtensions"),
-"Python3" : Preferences.getPython("Python3Extensions"),
+"Python3": Preferences.getPython("Python3Extensions"),
-"Ruby"    : ['.rb'],
+"Ruby": ['.rb'],
-"Mixed"   : ['.py', '.ptl', '.rb']
+"Mixed": ['.py', '.ptl', '.rb']
 }
 self.dbgFilters = {
-"Python2"  : self.trUtf8(
+"Python2": self.trUtf8(
 "Python2 Files (*.py2);;"
 "Python2 GUI Files (*.pyw2);;"),
-"Python3" : self.trUtf8(
+"Python3": self.trUtf8(
 "Python3 Files (*.py *.py3);;"
 "Python3 GUI Files (*.pyw *.pyw3);;"),
-"Ruby"    : self.trUtf8("Ruby Files (*.rb);;"),
+"Ruby": self.trUtf8("Ruby Files (*.rb);;"),
 }
 self.vcsMenu = None
 self.__initProjectTypes()
 else:
 self.vcs = self.initVCS()
 self.__model = ProjectBrowserModel(self)
-self.codemetrics        = None
+self.codemetrics = None
-self.codecoverage       = None
+self.codecoverage = None
-self.profiledata        = None
+self.profiledata = None
 self.applicationDiagram = None
 def __initProjectTypes(self):
 """
 Private method to initialize the list of supported project types.
 @param type_ internal type designator to be unregistered (string)
 """
 return type_ in self.__projectTypes
-def registerProjectType(self, type_, description, fileTypeCallback = None,
+def registerProjectType(self, type_, description, fileTypeCallback=None,
-binaryTranslationsCallback = None, lexerAssociationCallback = None):
+binaryTranslationsCallback=None, lexerAssociationCallback=None):
 """
 Public method to register a project type.
 @param type_ internal type designator to be registered (string)
 @param description more verbose type name (display string) (string)
 @keyparam fileTypeCallback reference to a method returning a dictionary
 of filetype associations.
 @keyparam binaryTranslationsCallback reference to a method returning the
 name of the binary translation file given the name of the raw
 translation file
 @keyparam lexerAssociationCallback reference to a method returning the
 lexer type to be used for syntax highlighting given the name of
 a file
 """
 self.ppath = ""         # name of the project directory
 self.ppathRe = None
 self.translationsRoot = ""  # the translations prefix
 self.name = ""
 self.opened = False
-self.subdirs = [""] # record the project dir as a relative path (i.e. empty path)
+self.subdirs = [""]  # record the project dir as a relative path (i.e. empty path)
 self.otherssubdirs = []
 self.vcs = None
 self.dbgCmdline = ''
 self.dbgWd = ''
 self.dbgEnv = ''
 PROJECTTYPESPECIFICDATA, CHECKERSPARMS, PACKAGERSPARMS, DOCUMENTATIONPARMS
 or OTHERTOOLSPARMS)
 @param key key of the data entry to get (string).
 @return a copy of the requested data or None
 """
 if category in ["PROJECTTYPESPECIFICDATA", "CHECKERSPARMS", "PACKAGERSPARMS",
 "DOCUMENTATIONPARMS", "OTHERTOOLSPARMS"] and \
 key in self.pdata[category]:
 return copy.deepcopy(self.pdata[category][key])
 else:
 return None
 or OTHERTOOLSPARMS)
 @param key key of the data entry to get (string).
 @param data data to be stored
 @return flag indicating success (boolean)
 """
-if category not in ["PROJECTTYPESPECIFICDATA","CHECKERSPARMS", "PACKAGERSPARMS",
+if category not in ["PROJECTTYPESPECIFICDATA", "CHECKERSPARMS", "PACKAGERSPARMS",
 "DOCUMENTATIONPARMS", "OTHERTOOLSPARMS"]:
 return False
 # test for changes of data and save them in the project
 # 1. there were none, now there are
 self.pdata["FILETYPES"]["*{0}".format(ext)] = "SOURCES"
 self.pdata["FILETYPES"]["*.idl"] = "INTERFACES"
 if self.pdata["PROJECTTYPE"][0] in ["Qt4", "E4Plugin", "PySide"]:
 self.pdata["FILETYPES"]["*.ui"] = "FORMS"
 self.pdata["FILETYPES"]["*.ui.h"] = "FORMS"
 if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C", "E4Plugin",
 "PySide", "PySideC"]:
 self.pdata["FILETYPES"]["*.qrc"] = "RESOURCES"
 if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C", "E4Plugin",
 "PySide", "PySideC"]:
 self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
 self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
 try:
 if self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"][0]] is not None:
 def updateFileTypes(self):
 """
 Public method to update the filetype associations with new default values.
 """
 if self.pdata["PROJECTTYPE"][0] in ["Qt4", "Qt4C", "E4Plugin",
 "PySide", "PySideC"]:
 if "*.ts" not in self.pdata["FILETYPES"]:
 self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
 if "*.qm" not in self.pdata["FILETYPES"]:
 self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
 """
 return self.opened
 def __checkFilesExist(self, index):
 """
 Private method to check, if the files in a list exist.
 The files in the indicated list are checked for existance in the
 filesystem. Non existant files are removed from the list and the
 dirty state of the project is changed accordingly.
 def __makePpathRe(self):
 """
 Private method to generate a regular expression for the project path.
 """
 ppathRe = (self.ppath + os.sep)\
-.replace("\\","@@")\
+.replace("\\", "@@")\
-.replace("/","@@")\
+.replace("/", "@@")\
-.replace("@@",r"[\\/]")
+.replace("@@", r"[\\/]")
 if Utilities.isWindowsPlatform():
 self.ppathRe = re.compile(ppathRe, re.IGNORECASE)
 else:
 self.ppathRe = re.compile(ppathRe)
 # create hash value, if it doesn't have one
 if not self.pdata["HASH"][0]:
 hash = str(QCryptographicHash.hash(
 QByteArray(self.ppath), QCryptographicHash.Sha1).toHex(),
-encoding = "utf-8")
+encoding="utf-8")
 self.pdata["HASH"] = [hash]
 self.setDirty(True)
 return res
-def __writeProject(self, fn = None):
+def __writeProject(self, fn=None):
 """
 Private method to save the project infos to a project file.
 @param fn optional filename of the project file to be written (string).
 If fn is None, the filename stored in the project object
 E5MessageBox.critical(self.ui,
 self.trUtf8("Save user project properties"),
 self.trUtf8("<p>The user specific project properties file <b>{0}</b>"
 " could not be written.</p>").format(fn))
-def __readSession(self, quiet = False, indicator = ""):
+def __readSession(self, quiet=False, indicator=""):
 """
 Private method to read in the project session file (.e4s)
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 self.trUtf8("Read project session"),
 self.trUtf8("Please save the project first."))
 return
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
 fn = os.path.join(self.getProjectManagementDir(),
 '{0}{1}.e4s'.format(fn, indicator))
 f = QFile(fn)
 if f.open(QIODevice.ReadOnly):
 reader = SessionReader(f, False)
-reader.readXML(quiet = quiet)
+reader.readXML(quiet=quiet)
 f.close()
 else:
 if not quiet:
 E5MessageBox.critical(self.ui,
 self.trUtf8("Read project session"),
 self.trUtf8("<p>The project session file <b>{0}</b> could not be"
 " read.</p>").format(fn))
-def __writeSession(self, quiet = False, indicator = ""):
+def __writeSession(self, quiet=False, indicator=""):
 """
 Private method to write the session data to an XML file (.e4s).
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 self.trUtf8("Save project session"),
 self.trUtf8("Please save the project first."))
 return
 fn, ext = os.path.splitext(os.path.basename(self.pfile))
 fn = os.path.join(self.getProjectManagementDir(),
 '{0}{1}.e4s'.format(fn, indicator))
 f = QFile(fn)
 if f.open(QIODevice.WriteOnly):
 SessionWriter(f, os.path.splitext(os.path.basename(fn))[0]).writeXML()
 return
 TasksWriter(f, True, os.path.splitext(os.path.basename(fn))[0]).writeXML()
 f.close()
-def __readDebugProperties(self, quiet = False):
+def __readDebugProperties(self, quiet=False):
 """
 Private method to read in the project debugger properties file (.e4d)
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 fn = os.path.join(self.getProjectManagementDir(), '{0}.e4d'.format(fn))
 f = QFile(fn)
 if f.open(QIODevice.ReadOnly):
 reader = DebuggerPropertiesReader(f, self)
-reader.readXML(quiet = quiet)
+reader.readXML(quiet=quiet)
 f.close()
 else:
 if not quiet:
 E5MessageBox.critical(self.ui,
 self.trUtf8("Read debugger properties"),
 self.trUtf8("<p>The project debugger properties file <b>{0}</b> could"
 " not be read.</p>").format(fn))
-def __writeDebugProperties(self, quiet = False):
+def __writeDebugProperties(self, quiet=False):
 """
 Private method to write the project debugger properties file (.e4d)
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
 @param key key of the property (string)
 @return value of the property
 """
 return self.debugProperties[key]
 def setDbgInfo(self, argv, wd, env, excReporting, excList, excIgnoreList,
-autoClearShell, tracePython = None, autoContinue = None):
+autoClearShell, tracePython=None, autoContinue=None):
 """
 Public method to set the debugging information.
 @param argv command line arguments to be used (string)
 @param wd working directory (string)
 """
 qmFile = ""
 try:
 if self.__binaryTranslationsCallbacks[self.pdata["PROJECTTYPE"][0]] \
 is not None:
-qmFile = self.__binaryTranslationsCallbacks\
+qmFile = self.__binaryTranslationsCallbacks[
-[self.pdata["PROJECTTYPE"][0]](langFile)
+self.pdata["PROJECTTYPE"][0]](langFile)
 except KeyError:
 qmFile = langFile.replace('.ts', '.qm')
 if qmFile == langFile:
 qmFile = ""
 return qmFile
 self.trUtf8("Delete translation"),
 self.trUtf8("<p>The selected translation file <b>{0}</b> could not be"
 " deleted.</p>").format(qmFile))
 return
-def appendFile(self, fn, isSourceFile = False, updateModel = True):
+def appendFile(self, fn, isSourceFile=False, updateModel=True):
 """
 Public method to append a file to the project.
 @param fn filename to be added to the project (string)
 @param isSourceFile flag indicating that this is a source file
 self.otherssubdirs.append(newdir)
 if dirty:
 self.setDirty(True)
-def addFiles(self, filter = None, startdir = None):
+def addFiles(self, filter=None, startdir=None):
 """
 Public slot used to add files to the project.
 @param filter filter to be used by the add file dialog
 (string out of source, form, resource, interface, others)
 @param startdir start directory for the selection dialog
 """
 if startdir is None:
 startdir = self.ppath
-dlg = AddFileDialog(self, self.parent(), filter, startdir = startdir)
+dlg = AddFileDialog(self, self.parent(), filter, startdir=startdir)
 if dlg.exec_() == QDialog.Accepted:
 fnames, target, isSource = dlg.getData()
 if target != '':
 for fn in fnames:
 targetfile = os.path.join(target, os.path.basename(fn))
 res = E5MessageBox.yesNo(self.ui,
 self.trUtf8("Add file"),
 self.trUtf8("<p>The file <b>{0}</b> already"
 " exists.</p><p>Overwrite it?</p>")
 .format(targetfile),
-icon = E5MessageBox.Warning)
+icon=E5MessageBox.Warning)
 if not res:
 return  # don't overwrite
 shutil.copy(fn, target)
 except IOError as why:
 else:
 E5MessageBox.critical(self.ui,
 self.trUtf8("Add file"),
 self.trUtf8("The target directory must not be empty."))
-def __addSingleDirectory(self, filetype, source, target, quiet = False):
+def __addSingleDirectory(self, filetype, source, target, quiet=False):
 """
 Private method used to add all files of a single directory to the project.
 @param filetype type of files to add (string)
 @param source source directory (string)
 res = E5MessageBox.yesNo(self.ui,
 self.trUtf8("Add directory"),
 self.trUtf8("<p>The file <b>{0}</b> already exists.</p>"
 "<p>Overwrite it?</p>")
 .format(targetfile),
-icon = E5MessageBox.Warning)
+icon=E5MessageBox.Warning)
 if not res:
 continue  # don't overwrite, carry on with next file
 shutil.copy(file, target)
 except EnvironmentError:
 ns = os.path.join(source, name)
 if os.path.isdir(ns):
 nt = os.path.join(target, name)
 self.__addRecursiveDirectory(filetype, ns, nt)
-def addDirectory(self, filter = None, startdir = None):
+def addDirectory(self, filter=None, startdir=None):
 """
 Public method used to add all files of a directory to the project.
 @param filter filter to be used by the add directory dialog
 (string out of source, form, resource, interface, others)
 @param startdir start directory for the selection dialog (string)
 """
 if startdir is None:
 startdir = self.ppath
-dlg = AddDirectoryDialog(self, filter, self.parent(), startdir = startdir)
+dlg = AddDirectoryDialog(self, filter, self.parent(), startdir=startdir)
 if dlg.exec_() == QDialog.Accepted:
 filetype, source, target, recursive = dlg.getData()
 if target == '':
 E5MessageBox.critical(self.ui,
 self.trUtf8("Add directory"),
 fn = self.getRelativePath(newfn)
 self.pdata["MAINSCRIPT"] = [fn]
 self.setDirty(True)
-def renameFile(self, oldfn, newfn = None):
+def renameFile(self, oldfn, newfn=None):
 """
 Public slot to rename a file of the project.
 @param oldfn old filename of the file (string)
 @param newfn new filename of the file (string)
 res = E5MessageBox.yesNo(self.ui,
 self.trUtf8("Rename File"),
 self.trUtf8("""<p>The file <b>{0}</b> already exists."""
 """ Overwrite it?</p>""")
 .format(newfn),
-icon = E5MessageBox.Warning)
+icon=E5MessageBox.Warning)
 if not res:
 return False
 try:
 os.rename(oldfn, newfn)
 fn in self.pdata["OTHERS"]:
 self.renameFileInPdata(oldfn, newfn, isSourceFile)
 return True
-def renameFileInPdata(self, oldname, newname, isSourceFile = False):
+def renameFileInPdata(self, oldname, newname, isSourceFile=False):
 """
 Public method to rename a file in the pdata structure.
 @param oldname old filename (string)
 @param newname new filename (string)
 del typeStrings[0]
 self.__model.removeItem(olddn)
 self.__model.addNewItem(typeString, newdn, typeStrings)
 self.directoryRemoved.emit(olddn)
-def removeFile(self, fn, updateModel = True):
+def removeFile(self, fn, updateModel=True):
 """
 Public slot to remove a file from the project.
 The file is not deleted from the project directory.
 self.projectAboutToBeCreated.emit()
 hash = str(QCryptographicHash.hash(
 QByteArray(self.ppath), QCryptographicHash.Sha1).toHex(),
-encoding = "utf-8")
+encoding="utf-8")
 self.pdata["HASH"] = [hash]
 # create the project directory if it doesn't exist already
 if not os.path.isdir(self.ppath):
 try:
 return
 # create an empty __init__.py file to make it a Python package
 # (only for Python and Python3)
 if self.pdata["PROGLANGUAGE"][0] in ["Python", "Python2", "Python3"]:
 fn = os.path.join(self.ppath, "__init__.py")
-f = open(fn, "w", encoding = "utf-8")
+f = open(fn, "w", encoding="utf-8")
 f.close()
 self.appendFile(fn, True)
 # create an empty main script file, if a name was given
 if len(self.pdata["MAINSCRIPT"]) and self.pdata["MAINSCRIPT"][0]:
 if not os.path.isabs(self.pdata["MAINSCRIPT"][0]):
 # add existing files to the project
 res = E5MessageBox.yesNo(self.ui,
 self.trUtf8("New Project"),
 self.trUtf8("""Add existing files to the project?"""),
-yesDefault = True)
+yesDefault=True)
 if res:
 self.newProjectAddFiles(ms)
 # create an empty __init__.py file to make it a Python package
 # if none exists (only for Python and Python3)
 if self.pdata["PROGLANGUAGE"][0] in ["Python", "Python2", "Python3"]:
 fn = os.path.join(self.ppath, "__init__.py")
 if not os.path.exists(fn):
-f = open(fn, "w", encoding = "utf-8")
+f = open(fn, "w", encoding="utf-8")
 f.close()
 self.appendFile(fn, True)
 self.saveProject()
 # check, if the existing project directory is already under
 if res == 0:
 apres = E5MessageBox.yesNo(self.ui,
 self.trUtf8("New project"),
 self.trUtf8("Shall the project file be added"
 " to the repository?"),
-yesDefault = True)
+yesDefault=True)
 if apres:
 self.saveProject()
 self.vcs.vcsAdd(self.pfile)
 else:
 self.pdata["VCS"] = ['None']
 if '_' in os.path.basename(tslist[0]):
 # the first entry determines the mainscript name
 mainscriptname = os.path.splitext(mainscript)[0] or \
 os.path.basename(tslist[0]).split('_')[0]
 self.pdata["TRANSLATIONPATTERN"] = \
 [os.path.join(os.path.dirname(tslist[0]),
 "{0}_%language%{1}".format(os.path.basename(tslist[0]).split('_')[0],
 os.path.splitext(tslist[0])[1]))]
 else:
 pattern, ok = QInputDialog.getText(
 None,
 self.trUtf8("Translation Pattern"),
 self.trUtf8("Enter the path pattern for translation files "
 "(use '%language%' in place of the language code):"),
 QLineEdit.Normal,
 tslist[0])
 if not pattern.isEmpty:
 self.pdata["TRANSLATIONPATTERN"] = [pattern]
 self.pdata["TRANSLATIONPATTERN"][0] = \
 self.getRelativePath(self.pdata["TRANSLATIONPATTERN"][0])
 if self.pdata["PROGLANGUAGE"][0] in ["Python", "Python2", "Python3"]:
 self.pdata["MAINSCRIPT"] = ['{0}.py'.format(mainscriptname)]
 elif self.pdata["PROGLANGUAGE"][0] == "Ruby":
 self.pdata["MAINSCRIPT"] = ['{0}.rb'.format(mainscriptname)]
 if self.pdata["TRANSLATIONSBINPATH"]:
 tpd = os.path.join(self.ppath,
 self.pdata["TRANSLATIONSBINPATH"][0])
 pattern = os.path.splitext(
 os.path.basename(self.pdata["TRANSLATIONPATTERN"][0]))
 pattern = self.__binaryTranslationFile(pattern)
 qmlist = Utilities.direntries(tpd, True, pattern)
 pass
 # return empty string to signal to use the global setting
 return ""
-def openProject(self, fn = None, restoreSession = True, reopen = False):
+def openProject(self, fn=None, restoreSession=True, reopen=False):
 """
 Public slot to open a project.
 @param fn optional filename of the project file to be read
 @param restoreSession flag indicating to restore the project
 self.sourceFile.emit(
 os.path.join(self.ppath, self.pdata["MAINSCRIPT"][0]))
 # open a project session file being quiet about errors
 if reopen:
-self.__readSession(quiet = True, indicator = "_tmp")
+self.__readSession(quiet=True, indicator="_tmp")
 elif Preferences.getProject("AutoLoadSession"):
-self.__readSession(quiet = True)
+self.__readSession(quiet=True)
 # open a project debugger properties file being quiet about errors
 if Preferences.getProject("AutoLoadDbgProperties"):
 self.__readDebugProperties(True)
 def reopenProject(self):
 """
 Public slot to reopen the current project.
 """
 projectFile = self.pfile
-res = self.closeProject(reopen = True)
+res = self.closeProject(reopen=True)
 if res:
-self.openProject(projectFile, reopen = True)
+self.openProject(projectFile, reopen=True)
 def saveProject(self):
 """
 Public slot to save the current project.
 if QFileInfo(fn).exists():
 res = E5MessageBox.yesNo(self.ui,
 self.trUtf8("Save File"),
 self.trUtf8("""<p>The file <b>{0}</b> already exists."""
 """ Overwrite it?</p>""").format(fn),
-icon = E5MessageBox.Warning)
+icon=E5MessageBox.Warning)
 if not res:
 return False
 self.name = QFileInfo(fn).baseName()
 ok = self.__writeProject(fn)
 Public method to check dirty status and open a message window.
 @return flag indicating whether this operation was successful (boolean)
 """
 if self.isDirty():
 res = E5MessageBox.okToClearData(self.parent(),
 self.trUtf8("Close Project"),
 self.trUtf8("The current project has unsaved changes."),
 self.saveProject)
 if res:
 self.setDirty(False)
 self.codemetrics        and self.codemetrics.close()
 self.codecoverage       and self.codecoverage.close()
 self.profiledata        and self.profiledata.close()
 self.applicationDiagram and self.applicationDiagram.close()
-def closeProject(self, reopen = False, noSave = False):
+def closeProject(self, reopen=False, noSave=False):
 """
 Public slot to close the current project.
 @keyparam reopen flag indicating a reopening of the project (boolean)
 @keyparam noSave flag indicating to not perform save actions (boolean)
 if not noSave:
 self.__writeUserProperties()
 # save the project session file being quiet about error
 if reopen:
-self.__writeSession(quiet = True, indicator = "_tmp")
+self.__writeSession(quiet=True, indicator="_tmp")
 elif Preferences.getProject("AutoSaveSession") and not noSave:
-self.__writeSession(quiet = True)
+self.__writeSession(quiet=True)
 # save the project debugger properties file being quiet about error
 if Preferences.getProject("AutoSaveDbgProperties") and \
 self.isDebugPropertiesLoaded() and \
 not noSave:
 self.projectClosedHooks.emit()
 self.projectClosed.emit()
 return True
-def saveAllScripts(self, reportSyntaxErrors = False):
+def saveAllScripts(self, reportSyntaxErrors=False):
 """
 Public method to save all scripts belonging to the project.
 @keyparam reportSyntaxErrors flag indicating special reporting
 for syntax errors (boolean)
 )
 return False
 else:
 return success
-def getMainScript(self, normalized = False):
+def getMainScript(self, normalized=False):
 """
 Public method to return the main script filename.
 @param normalized flag indicating a normalized filename is wanted (boolean)
 @return filename of the projects main script (string)
 else:
 return self.pdata["MAINSCRIPT"]
 else:
 return None
-def getSources(self, normalized = False):
+def getSources(self, normalized=False):
 """
 Public method to return the source script files.
 @param normalized flag indicating a normalized filename is wanted (boolean)
 @return list of the projects scripts (list of string)
 """
 return Utilities.fromNativeSeparators(self.getRelativePath(path))
 def getAbsoluteUniversalPath(self, fn):
 """
 Public method to convert a project relative file path with universal
 separators to an absolute file path.
 @param fn file or directory name to convert (string)
 @return absolute path (string)
 """
 self.actGrp1 = createActionGroup(self)
 act = E5Action(self.trUtf8('New project'),
 UI.PixmapCache.getIcon("projectNew.png"),
 self.trUtf8('&New...'), 0, 0,
-self.actGrp1,'project_new')
+self.actGrp1, 'project_new')
 act.setStatusTip(self.trUtf8('Generate a new project'))
 act.setWhatsThis(self.trUtf8(
 """<b>New...</b>"""
 """<p>This opens a dialog for entering the info for a"""
 """ new project.</p>"""
 self.actions.append(act)
 act = E5Action(self.trUtf8('Open project'),
 UI.PixmapCache.getIcon("projectOpen.png"),
 self.trUtf8('&Open...'), 0, 0,
-self.actGrp1,'project_open')
+self.actGrp1, 'project_open')
 act.setStatusTip(self.trUtf8('Open an existing project'))
 act.setWhatsThis(self.trUtf8(
 """<b>Open...</b>"""
 """<p>This opens an existing project.</p>"""
 ))
 self.actGrp2 = createActionGroup(self)
 self.addFilesAct = E5Action(self.trUtf8('Add files to project'),
 UI.PixmapCache.getIcon("fileMisc.png"),
 self.trUtf8('Add &files...'), 0, 0,
-self.actGrp2,'project_add_file')
+self.actGrp2, 'project_add_file')
 self.addFilesAct.setStatusTip(self.trUtf8('Add files to the current project'))
 self.addFilesAct.setWhatsThis(self.trUtf8(
 """<b>Add files...</b>"""
 """<p>This opens a dialog for adding files"""
 """ to the current project. The place to add is"""
 self.actions.append(self.addFilesAct)
 self.addDirectoryAct = E5Action(self.trUtf8('Add directory to project'),
 UI.PixmapCache.getIcon("dirOpen.png"),
 self.trUtf8('Add directory...'), 0, 0,
-self.actGrp2,'project_add_directory')
+self.actGrp2, 'project_add_directory')
 self.addDirectoryAct.setStatusTip(
 self.trUtf8('Add a directory to the current project'))
 self.addDirectoryAct.setWhatsThis(self.trUtf8(
 """<b>Add directory...</b>"""
 """<p>This opens a dialog for adding a directory"""
 self.actions.append(self.addDirectoryAct)
 self.addLanguageAct = E5Action(self.trUtf8('Add translation to project'),
 UI.PixmapCache.getIcon("linguist4.png"),
 self.trUtf8('Add &translation...'), 0, 0,
-self.actGrp2,'project_add_translation')
+self.actGrp2, 'project_add_translation')
 self.addLanguageAct.setStatusTip(
 self.trUtf8('Add a translation to the current project'))
 self.addLanguageAct.setWhatsThis(self.trUtf8(
 """<b>Add translation...</b>"""
 """<p>This opens a dialog for add a translation"""
 self.addLanguageAct.triggered[()].connect(self.addLanguage)
 self.actions.append(self.addLanguageAct)
 act = E5Action(self.trUtf8('Search new files'),
 self.trUtf8('Searc&h new files...'), 0, 0,
-self.actGrp2,'project_search_new_files')
+self.actGrp2, 'project_search_new_files')
 act.setStatusTip(self.trUtf8('Search new files in the project directory.'))
 act.setWhatsThis(self.trUtf8(
 """<b>Search new files...</b>"""
 """<p>This searches for new files (sources, *.ui, *.idl) in the project"""
 """ directory and registered subdirectories.</p>"""
 self.chkGrp = createActionGroup(self)
 self.codeMetricsAct = E5Action(self.trUtf8('Code Metrics'),
 self.trUtf8('&Code Metrics...'), 0, 0,
-self.chkGrp,'project_code_metrics')
+self.chkGrp, 'project_code_metrics')
 self.codeMetricsAct.setStatusTip(
 self.trUtf8('Show some code metrics for the project.'))
 self.codeMetricsAct.setWhatsThis(self.trUtf8(
 """<b>Code Metrics...</b>"""
 """<p>This shows some code metrics for all Python files in the project.</p>"""
 self.codeMetricsAct.triggered[()].connect(self.__showCodeMetrics)
 self.actions.append(self.codeMetricsAct)
 self.codeCoverageAct = E5Action(self.trUtf8('Python Code Coverage'),
 self.trUtf8('Code Co&verage...'), 0, 0,
-self.chkGrp,'project_code_coverage')
+self.chkGrp, 'project_code_coverage')
 self.codeCoverageAct.setStatusTip(
 self.trUtf8('Show code coverage information for the project.'))
 self.codeCoverageAct.setWhatsThis(self.trUtf8(
 """<b>Code Coverage...</b>"""
 """<p>This shows the code coverage information for all Python files"""
 self.codeCoverageAct.triggered[()].connect(self.__showCodeCoverage)
 self.actions.append(self.codeCoverageAct)
 self.codeProfileAct = E5Action(self.trUtf8('Profile Data'),
 self.trUtf8('&Profile Data...'), 0, 0,
-self.chkGrp,'project_profile_data')
+self.chkGrp, 'project_profile_data')
 self.codeProfileAct.setStatusTip(
 self.trUtf8('Show profiling data for the project.'))
 self.codeProfileAct.setWhatsThis(self.trUtf8(
 """<b>Profile Data...</b>"""
 """<p>This shows the profiling data for the project.</p>"""
 self.codeProfileAct.triggered[()].connect(self.__showProfileData)
 self.actions.append(self.codeProfileAct)
 self.applicationDiagramAct = E5Action(self.trUtf8('Application Diagram'),
 self.trUtf8('&Application Diagram...'), 0, 0,
-self.chkGrp,'project_application_diagram')
+self.chkGrp, 'project_application_diagram')
 self.applicationDiagramAct.setStatusTip(
 self.trUtf8('Show a diagram of the project.'))
 self.applicationDiagramAct.setWhatsThis(self.trUtf8(
 """<b>Application Diagram...</b>"""
 """<p>This shows a diagram of the project.</p>"""
 self.pluginGrp = createActionGroup(self)
 self.pluginPkgListAct = E5Action(self.trUtf8('Create Package List'),
 UI.PixmapCache.getIcon("pluginArchiveList.png"),
 self.trUtf8('Create &Package List'), 0, 0,
-self.pluginGrp,'project_plugin_pkglist')
+self.pluginGrp, 'project_plugin_pkglist')
 self.pluginPkgListAct.setStatusTip(
 self.trUtf8('Create an initial PKGLIST file for an eric5 plugin.'))
 self.pluginPkgListAct.setWhatsThis(self.trUtf8(
 """<b>Create Package List</b>"""
 """<p>This creates an initial list of files to include in an eric5 """
 self.actions.append(self.pluginPkgListAct)
 self.pluginArchiveAct = E5Action(self.trUtf8('Create Plugin Archive'),
 UI.PixmapCache.getIcon("pluginArchive.png"),
 self.trUtf8('Create Plugin &Archive'), 0, 0,
-self.pluginGrp,'project_plugin_archive')
+self.pluginGrp, 'project_plugin_archive')
 self.pluginArchiveAct.setStatusTip(
 self.trUtf8('Create an eric5 plugin archive file.'))
 self.pluginArchiveAct.setWhatsThis(self.trUtf8(
 """<b>Create Plugin Archive</b>"""
 """<p>This creates an eric5 plugin archive file using the list of files """
 self.actions.append(self.pluginArchiveAct)
 self.pluginSArchiveAct = E5Action(self.trUtf8('Create Plugin Archive (Snapshot)'),
 UI.PixmapCache.getIcon("pluginArchiveSnapshot.png"),
 self.trUtf8('Create Plugin Archive (&Snapshot)'), 0, 0,
-self.pluginGrp,'project_plugin_sarchive')
+self.pluginGrp, 'project_plugin_sarchive')
 self.pluginSArchiveAct.setStatusTip(
 self.trUtf8('Create an eric5 plugin archive file (snapshot release).'))
 self.pluginSArchiveAct.setWhatsThis(self.trUtf8(
 """<b>Create Plugin Archive (Snapshot)</b>"""
 """<p>This creates an eric5 plugin archive file using the list of files """
 self.debuggerMenu = QMenu(self.trUtf8('Debugger'), menu)
 self.packagersMenu = QMenu(self.trUtf8('Pac&kagers'), menu)
 self.packagersMenu.setTearOffEnabled(True)
 self.__menus = {
-"Main"      : menu,
+"Main": menu,
-"Recent"    : self.recentMenu,
+"Recent": self.recentMenu,
-"VCS"       : self.vcsMenu,
+"VCS": self.vcsMenu,
-"Checks"    : self.checksMenu,
+"Checks": self.checksMenu,
-"Show"      : self.menuShow,
+"Show": self.menuShow,
-"Graphics"  : self.graphicsMenu,
+"Graphics": self.graphicsMenu,
-"Session"   : self.sessionMenu,
+"Session": self.sessionMenu,
-"Apidoc"    : self.apidocMenu,
+"Apidoc": self.apidocMenu,
-"Debugger"  : self.debuggerMenu,
+"Debugger": self.debuggerMenu,
-"Packagers" : self.packagersMenu,
+"Packagers": self.packagersMenu,
 }
 # connect the aboutToShow signals
 self.recentMenu.aboutToShow.connect(self.__showContextMenuRecent)
 self.recentMenu.triggered.connect(self.__openRecent)
 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
 """
 Private slot used to handle the search new files action.
 """
 self.__doSearchNewFiles(False, True)
-def __doSearchNewFiles(self, AI = True, onUserDemand = False):
+def __doSearchNewFiles(self, AI=True, onUserDemand=False):
 """
 Private method to search for new files in the project directory.
 If new files were found, it shows a dialog listing these files and
 gives the user the opportunity to select the ones he wants to
 include. If 'Automatic Inclusion' is enabled, the new files are
 automatically added to the project.
 @param AI flag indicating whether the automatic inclusion should
 be honoured (boolean)
 @param onUserDemand flag indicating whether this method was
 requested by the user via a menu action (boolean)
 """
 autoInclude = Preferences.getProject("AutoIncludeNewFiles")
 recursiveSearch = Preferences.getProject("SearchNewFilesRecursively")
 newFiles = []
 elif res == 2:
 files = dlg.getSelection()
 for file in files:
 self.appendFile(file)
-def othersAdded(self, fn, updateModel = True):
+def othersAdded(self, fn, updateModel=True):
 """
 Public slot to be called, if something was added to the OTHERS project data area.
 @param fn filename or directory name added (string)
 @param updateModel flag indicating an update of the model is requested (boolean)
 ##############################################################
 ## Below is the VCS interface
 ##############################################################
-def initVCS(self, vcsSystem = None, nooverride = False):
+def initVCS(self, vcsSystem=None, nooverride=False):
 """
 Public method used to instantiate a vcs system.
 @param vcsSystem type of VCS to be used (string)
 @param nooverride flag indicating to ignore an override request (boolean)
 vcs = VCS.factory(vcsSystem)
 except ImportError:
 if override:
 # override failed, revert to original
 self.pudata["VCSOVERRIDE"] = []
-return self.initVCS(nooverride = True)
+return self.initVCS(nooverride=True)
 if vcs:
 vcsExists, msg = vcs.vcsExists()
 if not vcsExists:
 if override:
 self.trUtf8("Version Control System"),
 self.trUtf8("<p>The selected VCS <b>{0}</b> could not be found."
 "<br/>Reverting override.</p><p>{1}</p>")\
 .format(vcsSystem, msg))
 self.pudata["VCSOVERRIDE"] = []
-return self.initVCS(nooverride = True)
+return self.initVCS(nooverride=True)
 QApplication.restoreOverrideCursor()
 E5MessageBox.critical(self.ui,
 self.trUtf8("Version Control System"),
 self.trUtf8("<p>The selected VCS <b>{0}</b> could not be found.<br/>"
 Private method to handle the application diagram context menu action.
 """
 res = E5MessageBox.yesNo(self.ui,
 self.trUtf8("Application Diagram"),
 self.trUtf8("""Include module names?"""),
-yesDefault = True)
+yesDefault=True)
 self.applicationDiagram = ApplicationDiagram(self, self.parent(),
-noModules = not res)
+noModules=not res)
 self.applicationDiagram.show()
 #########################################################################
 ## Below is the interface to the VCS monitor thread
 #########################################################################
 if os.path.exists(pkglist):
 res = E5MessageBox.yesNo(self.ui,
 self.trUtf8("Create Package List"),
 self.trUtf8("<p>The file <b>PKGLIST</b> already"
 " exists.</p><p>Overwrite it?</p>"),
-icon = E5MessageBox.Warning)
+icon=E5MessageBox.Warning)
 if not res:
 return  # don't overwrite
 # build the list of entries
 lst = []
 try:
 if self.pdata["EOL"][0] == 0:
 newline = None
 else:
 newline = self.getEolString()
-pkglistFile = open(pkglist, "w", encoding = "utf-8", newline = newline)
+pkglistFile = open(pkglist, "w", encoding="utf-8", newline=newline)
 pkglistFile.write("\n".join(lst))
 pkglistFile.close()
 except IOError as why:
 E5MessageBox.critical(self.ui,
 self.trUtf8("Create Package List"),
 return
 if not "PKGLIST" in self.pdata["OTHERS"]:
 self.appendFile("PKGLIST")
-def __pluginCreateArchive(self, snapshot = False):
+def __pluginCreateArchive(self, snapshot=False):
 """
 Private slot to create an eric5 plugin archive.
 @param snapshot flag indicating a snapshot archive (boolean)
 """
 self.trUtf8("""The project does not have a main script defined. """
 """Aborting..."""))
 return
 try:
-pkglistFile = open(pkglist, "r", encoding = "utf-8")
+pkglistFile = open(pkglist, "r", encoding="utf-8")
 names = pkglistFile.read()
 pkglistFile.close()
 names = sorted(names.splitlines())
 except IOError as why:
 E5MessageBox.critical(self.ui,
 if sourcelines[lineno].startswith("version = "):
 # found the line to modify
 datestr = time.strftime("%Y%m%d")
 lineend = sourcelines[lineno].replace(sourcelines[lineno].rstrip(), "")
 sversion = "{0}-snapshot-{1}".format(
 sourcelines[lineno].replace("version = ", "").strip()[1:-1],
 datestr)
 sourcelines[lineno] = '{0} + "-snapshot-{1}"{2}'.format(
 sourcelines[lineno].rstrip(), datestr, lineend)
 break

Mercurial Repositories > eric / file comparison

comparison: Project/Project.py

Project/Project.py