eric: comparison src/eric7/Project/Project.py

-:411df92e881f
+:3b34efa2857c
 # -*- coding: utf-8 -*-
-# Copyright (c) 2002 - 2023 Detlev Offenbach <detlev@die-offenbachs.de>
+# Copyright (c) 2002 - 2024 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the project management functionality.
 """
 def __init__(self, parent=None, filename=None):
 """
 Constructor
-@param parent parent widget (usually the ui object) (QWidget)
+@param parent parent widget (usually the ui object)
-@param filename optional filename of a project file to open (string)
+@type QWidget
+@param filename optional filename of a project file to open
+@type str
 """
 super().__init__(parent)
 self.ui = parent
 def __sourceExtensions(self, language):
 """
 Private method to get the source extensions of a programming language.
-@param language programming language (string)
+@param language programming language
-@return source extensions (list of string)
+@type str
+@return source extensions
+@rtype list of str
 """
 if language == "Python3":
 extensions = Preferences.getPython("Python3Extensions")
 # *.py and *.pyw should always be associated with source files
 for ext in [".py", ".pyw"]:
 def getProgrammingLanguages(self):
 """
 Public method to get the programming languages supported by project.
-@return list of supported programming languages (list of string)
+@return list of supported programming languages
+@rtype list of str
 """
 return self.__progLanguages[:]
 def getDebuggerFilters(self, language):
 """
 def getProjectTypes(self, progLanguage=""):
 """
 Public method to get the list of supported project types.
 @param progLanguage programming language to get project types for
-(string)
+@type str
 @return reference to the dictionary of project types.
+@rtype dict
 """
 if progLanguage and progLanguage in self.__projectProgLanguages:
 ptypes = {}
 for ptype in self.__projectProgLanguages[progLanguage]:
 ptypes[ptype] = self.__projectTypes[ptype]
 def hasProjectType(self, type_, progLanguage=""):
 """
 Public method to check, if a project type is already registered.
-@param type_ internal type designator (string)
+@param type_ internal type designator
-@param progLanguage programming language of the project type (string)
+@type str
-@return flag indicating presence of the project type (boolean)
+@param progLanguage programming language of the project type
+@type str
+@return flag indicating presence of the project type
+@rtype bool
 """
 if progLanguage:
 return (
 progLanguage in self.__projectProgLanguages
 and type_ in self.__projectProgLanguages[progLanguage]
 progLanguages=None,
 ):
 """
 Public method to register a project type.
-@param type_ internal type designator to be registered (string)
+@param type_ internal type designator to be registered
-@param description more verbose type name (display string) (string)
+@type str
+@param description more verbose type name (display string)
+@type str
 @param fileTypeCallback reference to a method returning a dictionary
-of filetype associations.
+of filetype associations
+@type function
 @param binaryTranslationsCallback reference to a method returning
 the name of the binary translation file given the name of the raw
 translation file
+@type function
 @param lexerAssociationCallback reference to a method returning the
 lexer type to be used for syntax highlighting given the name of
 a file
+@type function
 @param progLanguages programming languages supported by the
-project type (list of string)
+project type
+@type list of str
 """
 if progLanguages:
 for progLanguage in progLanguages:
 if progLanguage not in self.__projectProgLanguages:
 EricMessageBox.critical(
 def unregisterProjectType(self, type_):
 """
 Public method to unregister a project type.
-@param type_ internal type designator to be unregistered (string)
+@param type_ internal type designator to be unregistered
+@type str
 """
 for progLanguage in self.__projectProgLanguages:
 if type_ in self.__projectProgLanguages[progLanguage]:
 self.__projectProgLanguages[progLanguage].remove(type_)
 if type_ in self.__projectTypes:
 @param key key of the data entry to get
 @type str
 @param default value to return in case the key is not found (defaults to None)
 @type Any (optional)
 @return a copy of the requested data or None
+@rtype Any
 """
 # __IGNORE_WARNING_D202__
 if (
 category
 in [
 def setData(self, category, key, data):
 """
 Public method to store data in the project data store.
-@param category category of the data to get (string, one of
+@param category category of the data to get (one of
 PROJECTTYPESPECIFICDATA, CHECKERSPARMS, PACKAGERSPARMS,
 DOCUMENTATIONPARMS or OTHERTOOLSPARMS)
-@param key key of the data entry to get (string).
+@type str
+@param key key of the data entry to get
+@type str
 @param data data to be stored
-@return flag indicating success (boolean)
+@type Any
+@return flag indicating success
+@rtype bool
 """
 # __IGNORE_WARNING_D202__
 if category not in [
 "PROJECTTYPESPECIFICDATA",
 "CHECKERSPARMS",
 Public method to get the list of known file categories.
 @return list of known file categories
 @rtype list of str
 """
-return list(self.__fileCategoriesRepository.keys())
+return list(self.__fileCategoriesRepository)
 def getFileCategoryFilters(self, categories=None, withOthers=False, withAll=True):
 """
 Public method to get a list of file selection filters for the given categories.
 fileTypesDict["*.qm"] = "TRANSLATIONS"
 # File categories handled by activated plugin project browsers
 for fileCategory in [
 f
-for f in self.__fileCategoriesRepository.keys()
+for f in self.__fileCategoriesRepository
 if f not in ["SOURCES", "FORMS", "RESOURCES", "TRANSLATIONS", "OTHERS"]
 ]:
 for ext in self.__fileCategoriesRepository[
 fileCategory.upper()
 ].fileCategoryExtensions:
 if "*.qm" not in self.__pdata["FILETYPES"]:
 self.__pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
 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()):
+for pattern, ftype in ftypes.items():
 if pattern not in self.__pdata["FILETYPES"]:
 self.__pdata["FILETYPES"][pattern] = ftype
 self.setDirty(True)
 def __loadRecent(self):
 def getMostRecent(self):
 """
 Public method to get the most recently opened project.
-@return path of the most recently opened project (string)
+@return path of the most recently opened project
+@rtype str
 """
 if len(self.recent):
 return self.recent[0]
 else:
 return None
 def getModel(self):
 """
 Public method to get a reference to the project browser model.
-@return reference to the project browser model (ProjectBrowserModel)
+@return reference to the project browser model
+@rtype ProjectBrowserModel
 """
 return self.__model
 def startFileSystemMonitoring(self):
 """
 def getVcs(self):
 """
 Public method to get a reference to the VCS object.
 @return reference to the VCS object
+@rtype VersionControl
 """
 return self.vcs
 def isVcsControlled(self):
 """
 def isDirty(self):
 """
 Public method to return the dirty state.
-@return dirty state (boolean)
+@return dirty state
+@rtype bool
 """
 return self.__dirty
 def isOpen(self):
 """
 Public method to return the opened state.
-@return open state (boolean)
+@return open state
+@rtype bool
 """
 return self.opened
 def __checkFilesExist(self, index):
 """
 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.
-@param index key of the list to be checked (string)
+@param index key of the list to be checked
+@type str
 """
 removed = False
 removelist = []
 for file in self.__pdata[index]:
 if not os.path.exists(os.path.join(self.ppath, file)):
 def __readProject(self, fn):
 """
 Private method to read in a project (.epj or .e4p) file.
-@param fn filename of the project file to be read (string)
+@param fn filename of the project file to be read
+@type str
 @return flag indicating success
+@rtype bool
 """
 if os.path.splitext(fn)[1] == ".epj":
 # new JSON based format
 with EricOverrideCursor():
 res = self.__projectFile.readFile(fn)
 @param fn optional filename of the project file to be written (string).
 If fn is None, the filename stored in the project object
 is used. This is the 'save' action. If fn is given, this filename
 is used instead of the one in the project object. This is the
 'save as' action.
+@type str
 @return flag indicating success
+@rtype bool
 """
 if self.vcs is not None:
 self.__pdata["VCSOPTIONS"] = copy.deepcopy(self.vcs.vcsGetOptions())
 self.__pdata["VCSOTHERDATA"] = copy.deepcopy(self.vcs.vcsGetOtherData())
 """
 Private method to read in the project session file (.esj or .e5s).
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
-@param indicator indicator string (string)
+@type bool
+@param indicator indicator string
+@type str
 """
 if self.pfile is None:
 if not quiet:
 EricMessageBox.critical(
 self.ui,
 """
 Private method to write the session data to an XML file (.esj).
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
-@param indicator indicator string (string)
+@type bool
+@param indicator indicator string
+@type str
 """
 if self.pfile is None:
 if not quiet:
 EricMessageBox.critical(
 self.ui,
 Private method to read in the project debugger properties file
 (.edj or .e4d).
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
+@type bool
 """
 if self.pfile is None:
 if not quiet:
 EricMessageBox.critical(
 self.ui,
 """
 Private method to write the project debugger properties file (.edj).
 @param quiet flag indicating quiet operations.
 If this flag is true, no errors are reported.
+@type bool
 """
 if self.pfile is None:
 if not quiet:
 EricMessageBox.critical(
 self.ui,
 def isDebugPropertiesLoaded(self):
 """
 Public method to return the status of the debug properties.
-@return load status of debug properties (boolean)
+@return load status of debug properties
+@rtype bool
 """
 return self.debugPropertiesLoaded or self.__pdata["EMBEDDED_VENV"]
 def __showDebugProperties(self):
 """
 def getDebugProperty(self, key):
 """
 Public method to retrieve a debugger property.
-@param key key of the property (string)
+@param key key of the property
+@type str
 @return value of the property
+@rtype Any
 """
 if key == "INTERPRETER":
 return (
 ericApp()
 .getObject("VirtualEnvManager")
 def getTranslationPattern(self):
 """
 Public method to get the translation pattern.
-@return translation pattern (string)
+@return translation pattern
+@rtype str
 """
 return self.__pdata["TRANSLATIONPATTERN"]
 def setTranslationPattern(self, pattern):
 """
 def __binaryTranslationFile(self, langFile):
 """
 Private method to calculate the filename of the binary translations
 file given the name of the raw translations file.
-@param langFile name of the raw translations file (string)
+@param langFile name of the raw translations file
-@return name of the binary translations file (string)
+@type str
+@return name of the binary translations file
+@rtype str
 """
 qmFile = ""
 try:
 if (
 self.__binaryTranslationsCallbacks[self.__pdata["PROJECTTYPE"]]
 """
 Public slot to remove a translation from the project.
 The translation file is not deleted from the project directory.
-@param langFile the translation file to be removed (string)
+@param langFile the translation file to be removed
+@type str
 """
 langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
 with contextlib.suppress(ValueError):
 self.__model.removeItem(langFile)
 def deleteLanguageFile(self, langFile):
 """
 Public slot to delete a translation from the project directory.
-@param langFile the translation file to be removed (string)
+@param langFile the translation file to be removed
+@type str
 """
 langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
 try:
 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 fn filename to be added to the project
+@type str
 @param isSourceFile flag indicating that this is a source file
-even if it doesn't have the source extension (boolean)
+even if it doesn't have the source extension
+@type bool
 @param updateModel flag indicating an update of the model is
-requested (boolean)
+requested
+@type bool
 """
 dirty = False
 # make it relative to the project root, if it starts with that path
 # assume relative paths are relative to the project root
 filetype = "OTHERS"
 bfn = os.path.basename(newfn)
 if fnmatch.fnmatch(bfn, "*.ts") or fnmatch.fnmatch(bfn, "*.qm"):
 filetype = "TRANSLATIONS"
 else:
-for pattern in sorted(self.__pdata["FILETYPES"].keys(), reverse=True):
+for pattern in sorted(self.__pdata["FILETYPES"], reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
 filetype = self.__pdata["FILETYPES"][pattern]
 break
 if filetype == "__IGNORE__":
 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 filetype type of files to add
-@param source source directory (string)
+@type str
-@param target target directory (string)
+@param source source directory
-@param quiet flag indicating quiet operations (boolean)
+@type str
+@param target target directory
+@type str
+@param quiet flag indicating quiet operations
+@type bool
 """
 # get all relevant filename patterns
 patterns = []
 ignorePatterns = []
-for pattern, patterntype in list(self.__pdata["FILETYPES"].items()):
+for pattern, patterntype in self.__pdata["FILETYPES"].items():
 if patterntype == filetype:
 patterns.append(pattern)
 elif patterntype == "__IGNORE__":
 ignorePatterns.append(pattern)
 Private method used to add all files of a directory tree.
 The tree is rooted at source to another one rooted at target. This
 method decents down to the lowest subdirectory.
-@param filetype type of files to add (string)
+@param filetype type of files to add
-@param source source directory (string)
+@type str
-@param target target directory (string)
+@param source source directory
+@type str
+@param target target directory
+@type str
 """
 # first perform the addition of source
 self.__addSingleDirectory(filetype, source, target, True)
 ignore_patterns = [
 def addToOthers(self, fn):
 """
 Public method to add a file/directory to the OTHERS project data.
-@param fn file name or directory name to add (string)
+@param fn file name or directory name to add
+@type str
 """
 if fn:
 # if it is below the project directory, make it relative to that
 fn = self.getRelativePath(fn)
 def renameMainScript(self, oldfn, newfn):
 """
 Public method to rename the main script.
-@param oldfn old filename (string)
+@param oldfn old filename
-@param newfn new filename of the main script (string)
+@type str
+@param newfn new filename of the main script
+@type str
 """
 if self.__pdata["MAINSCRIPT"]:
 ofn = self.getRelativePath(oldfn)
 if ofn != self.__pdata["MAINSCRIPT"]:
 return
 def renameFile(self, oldfn, newfn=None):
 """
 Public slot to rename a file of the project.
-@param oldfn old filename of the file (string)
+@param oldfn old filename of the file
-@param newfn new filename of the file (string)
+@type str
+@param newfn new filename of the file
+@type str
 @return flag indicating success
+@rtype bool
 """
 fn = self.getRelativePath(oldfn)
 isSourceFile = fn in self.__pdata["SOURCES"]
 if newfn is None:
 def renameFileInPdata(self, oldname, newname, isSourceFile=False):
 """
 Public method to rename a file in the __pdata structure.
-@param oldname old filename (string)
+@param oldname old filename
-@param newname new filename (string)
+@type str
+@param newname new filename
+@type str
 @param isSourceFile flag indicating that this is a source file
-even if it doesn't have the source extension (boolean)
+even if it doesn't have the source extension
+@type bool
 """
 fn = self.getRelativePath(oldname)
 if os.path.dirname(oldname) == os.path.dirname(newname):
 if self.__isInPdata(oldname):
 self.removeFile(oldname, False)
 def getFiles(self, start):
 """
 Public method to get all files starting with a common prefix.
-@param start prefix (string)
+@param start prefix
-@return list of files starting with a common prefix (list of strings)
+@type str
+@return list of files starting with a common prefix
+@rtype list of str
 """
 filelist = []
 start = self.getRelativePath(start)
 for fileCategory in [
 c for c in self.getFileCategories() if c != "TRANSLATIONS"
 # iterate over all files checking for a reassignment
 for fileCategory in self.getFileCategories():
 for fn in self.__pdata[fileCategory][:]:
 filetype = fileCategory
 bfn = os.path.basename(fn)
-for pattern in sorted(self.__pdata["FILETYPES"].keys(), reverse=True):
+for pattern in sorted(self.__pdata["FILETYPES"], reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
 filetype = self.__pdata["FILETYPES"][pattern]
 break
 if filetype != "__IGNORE__":
 def copyDirectory(self, olddn, newdn):
 """
 Public slot to copy a directory.
-@param olddn original directory name (string)
+@param olddn original directory name
-@param newdn new directory name (string)
+@type str
+@param newdn new directory name
+@type str
 """
 olddn = self.getRelativePath(olddn)
 newdn = self.getRelativePath(newdn)
 for fileCategory in [
 c for c in self.getFileCategories() if c != "TRANSLATIONS"
 def moveDirectory(self, olddn, newdn):
 """
 Public slot to move a directory.
-@param olddn old directory name (string)
+@param olddn old directory name
-@param newdn new directory name (string)
+@type str
+@param newdn new directory name
+@type str
 """
 olddn = self.getRelativePath(olddn)
 newdn = self.getRelativePath(newdn)
 typeStrings = []
 for fileCategory in [
 Public slot to remove a file from the project.
 The file is not deleted from the project directory.
 @param fn filename to be removed from the project
-@param updateModel flag indicating an update of the model is
+@type str
-requested (boolean)
+@param updateModel flag indicating an update of the model is requested
+@type bool
 """
 fn = self.getRelativePath(fn)
 for fileCategory in self.getFileCategories():
 if fn in self.__pdata[fileCategory]:
 self.__pdata[fileCategory].remove(fn)
 Public method to remove a directory from the project.
 The directory is not deleted from the project directory.
 @param dn directory name to be removed from the project
+@type str
 """
 dirty = False
 dn = self.getRelativePath(dn)
 for entry in self.__pdata["OTHERS"][:]:
 if entry.startswith(dn):
 def deleteFile(self, fn):
 """
 Public method to delete a file from the project directory.
 @param fn filename to be deleted from the project
-@return flag indicating success (boolean)
+@type str
+@return flag indicating success
+@rtype bool
 """
 try:
 os.remove(os.path.join(self.ppath, fn))
 path, ext = os.path.splitext(fn)
 if ext == ".ui":
 def deleteDirectory(self, dn):
 """
 Public method to delete a directory from the project directory.
 @param dn directory name to be removed from the project
-@return flag indicating success (boolean)
+@type str
+@return flag indicating success
+@rtype bool
 """
 if not os.path.isabs(dn):
 dn = os.path.join(self.ppath, dn)
 try:
-shutil.rmtree(dn, True)
+shutil.rmtree(dn, ignore_errors=True)
 except OSError as err:
 EricMessageBox.critical(
 self.ui,
 self.tr("Delete directory"),
 self.tr(
 def hasEntry(self, fn):
 """
 Public method to check the project for a file.
-@param fn filename to be checked (string)
+@param fn filename to be checked
-@return flag indicating, if the project contains the file (boolean)
+@type str
+@return flag indicating, if the project contains the file
+@rtype bool
 """
 fn = self.getRelativePath(fn)
 return any(
 fn in self.__pdata[category]
 for category in self.getFileCategories()
 ericApp()
 .getObject("PluginManager")
 .getPluginDisplayStrings("version_control")
 )
 vcsSystemsDisplay = [self.tr("None")]
-keys = sorted(vcsSystemsDict.keys())
+for key in sorted(vcsSystemsDict):
-for key in keys:
 vcsSystemsDisplay.append(vcsSystemsDict[key])
 vcsSelected, ok = QInputDialog.getItem(
 None,
 self.tr("New Project"),
 self.tr("Select version control system for the project"),
 def newProjectAddFiles(self, mainscript):
 """
 Public method to add files to a new project.
-@param mainscript name of the mainscript (string)
+@param mainscript name of the mainscript
+@type str
 """
 # Show the file type associations for the user to change
 self.__showFiletypeAssociations()
 ignoreList = []
 if environmentPath:
 # there is already an embeded venv; ignore thie whenn adding files
 ignoreList = [os.path.split(environmentPath)[-1]]
 with EricOverrideCursor():
 # search the project directory for files with known extensions
-filespecs = list(self.__pdata["FILETYPES"].keys())
+for filespec in self.__pdata["FILETYPES"]:
-for filespec in filespecs:
 files = FileSystemUtilities.direntries(
 self.ppath,
 filesonly=True,
 pattern=filespec,
 ignore=ignoreList,
 def getEditorLexerAssoc(self, filename):
 """
 Public method to retrieve a lexer association.
 @param filename filename used to determine the associated lexer
-language (string)
+language
-@return the requested lexer language (string)
+@type str
+@return the requested lexer language
+@rtype str
 """
 # try user settings first
-for pattern, language in list(self.__pdata["LEXERASSOCS"].items()):
+for pattern, language in self.__pdata["LEXERASSOCS"].items():
 if fnmatch.fnmatch(filename, pattern):
 return language
 # try project type specific defaults next
 projectType = self.__pdata["PROJECTTYPE"]
 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
+@type str
 @param restoreSession flag indicating to restore the project
-session (boolean)
+session
-@param reopen flag indicating a reopening of the project (boolean)
+@type bool
+@param reopen flag indicating a reopening of the project
+@type bool
 """
 if not self.checkDirty():
 return
 if fn is None:
 def saveProject(self):
 """
 Public slot to save the current project.
 @return flag indicating success
+@rtype bool
 """
 if self.isDirty():
 if len(self.pfile) > 0:
 if self.pfile.endswith(".e4p"):
 self.pfile = self.pfile.replace(".e4p", ".epj")
 def saveProjectAs(self):
 """
 Public slot to save the current project to a different file.
-@return flag indicating success (boolean)
+@return flag indicating success
+@rtype bool
 """
 defaultFilter = self.tr("Project Files (*.epj)")
 defaultPath = (
 self.ppath
 if self.ppath
 def checkDirty(self):
 """
 Public method to check dirty status and open a message window.
-@return flag indicating whether this operation was successful (boolean)
+@return flag indicating whether this operation was successful
+@rtype bool
 """
 if self.isDirty():
 res = EricMessageBox.okToClearData(
 self.parent(),
 self.tr("Close Project"),
 def saveAllScripts(self, reportSyntaxErrors=False):
 """
 Public method to save all scripts belonging to the project.
 @param reportSyntaxErrors flag indicating special reporting
-for syntax errors (boolean)
+for syntax errors
-@return flag indicating success (boolean)
+@type bool
+@return flag indicating success
+@rtype bool
 """
 vm = ericApp().getObject("ViewManager")
 success = True
 filesWithSyntaxErrors = 0
 for fn in vm.getOpenFilenames():
 """
 Public method to check all scripts belonging to the project for
 their dirty status.
 @param reportSyntaxErrors flag indicating special reporting
-for syntax errors (boolean)
+for syntax errors
-@return flag indicating success (boolean)
+@type bool
+@return flag indicating success
+@rtype bool
 """
 vm = ericApp().getObject("ViewManager")
 success = True
 filesWithSyntaxErrors = 0
 for fn in vm.getOpenFilenames():
 def getProjectType(self):
 """
 Public method to get the type of the project.
-@return UI type of the project (string)
+@return UI type of the project
+@rtype str
 """
 return self.__pdata["PROJECTTYPE"]
 def getProjectLanguage(self):
 """
 Public method to get the project's programming language.
-@return programming language (string)
+@return programming language
+@rtype str
 """
 return self.__pdata["PROGLANGUAGE"]
 def isMixedLanguageProject(self):
 """
 def isPythonProject(self):
 """
 Public method to check, if this project is a Python3 or MicroPython
 project.
-@return flag indicating a Python project (boolean)
+@return flag indicating a Python project
+@rtype bool
 """
 return self.__pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]
 def isPy3Project(self):
 """
 Public method to check, if this project is a Python3 project.
-@return flag indicating a Python3 project (boolean)
+@return flag indicating a Python3 project
+@rtype bool
 """
 return self.__pdata["PROGLANGUAGE"] == "Python3"
 def isMicroPythonProject(self):
 """
 def isRubyProject(self):
 """
 Public method to check, if this project is a Ruby project.
-@return flag indicating a Ruby project (boolean)
+@return flag indicating a Ruby project
+@rtype bool
 """
 return self.__pdata["PROGLANGUAGE"] == "Ruby"
 def isJavaScriptProject(self):
 """
 Public method to check, if this project is a JavaScript project.
-@return flag indicating a JavaScript project (boolean)
+@return flag indicating a JavaScript project
+@rtype bool
 """
 return self.__pdata["PROGLANGUAGE"] == "JavaScript"
 def getProjectSpellLanguage(self):
 """
 Public method to get the project's programming language.
-@return programming language (string)
+@return programming language
+@rtype str
 """
 return self.__pdata["SPELLLANGUAGE"]
 def getProjectDictionaries(self):
 """
 Public method to get the names of the project specific dictionaries.
-@return tuple of two strings giving the absolute path names of the
+@return tuple containing the absolute path names of the project specific
-project specific word and exclude list
+word and exclude list
+@rtype tuple of (str, str)
 """
 pwl = ""
 if self.__pdata["SPELLWORDS"]:
 pwl = os.path.join(self.ppath, self.__pdata["SPELLWORDS"])
 if not os.path.isfile(pwl):
 def getDefaultSourceExtension(self):
 """
 Public method to get the default extension for the project's
 programming language.
-@return default extension (including the dot) (string)
+@return default extension (including the dot)
+@rtype str
 """
 lang = self.__pdata["PROGLANGUAGE"]
 if lang in ("", "Python"):
 lang = "Python3"
 return self.__sourceExtensions(lang)[0]
 def getProjectPath(self):
 """
 Public method to get the project path.
-@return project path (string)
+@return project path
+@rtype str
 """
 return self.ppath
 def startswithProjectPath(self, path):
 """
 def getProjectFile(self):
 """
 Public method to get the path of the project file.
-@return path of the project file (string)
+@return path of the project file
+@rtype str
 """
 return self.pfile
 def getProjectName(self):
 """
 Public method to get the name of the project.
 The project name is determined from the name of the project file.
-@return name of the project (string)
+@return name of the project
+@rtype str
 """
 if self.pfile:
 name = os.path.splitext(self.pfile)[0]
 return os.path.basename(name)
 else:
 def getProjectManagementDir(self):
 """
 Public method to get the path of the management directory.
-@return path of the management directory (string)
+@return path of the management directory
+@rtype str
 """
 return os.path.join(self.ppath, ".eric7project")
 def createProjectManagementDir(self):
 """
 def getHash(self):
 """
 Public method to get the project hash.
-@return project hash as a hex string (string)
+@return project hash as a hex string
+@rtype str
 """
 return self.__pdata["HASH"]
 def getRelativePath(self, path):
 """
 Public method to convert a file path to a project relative
 file path.
-@param path file or directory name to convert (string)
+@param path file or directory name to convert
+@type str
 @return project relative path or unchanged path, if path doesn't
-belong to the project (string)
+belong to the project
+@rtype str
 """
 if path is None:
 return ""
 try:
 def getRelativeUniversalPath(self, path):
 """
 Public method to convert a file path to a project relative
 file path with universal separators.
-@param path file or directory name to convert (string)
+@param path file or directory name to convert
+@type str
 @return project relative path or unchanged path, if path doesn't
-belong to the project (string)
+belong to the project
+@rtype str
 """
 return FileSystemUtilities.fromNativeSeparators(self.getRelativePath(path))
 def getAbsolutePath(self, fn):
 """
 Public method to convert a project relative file path to an absolute
 file path.
-@param fn file or directory name to convert (string)
+@param fn file or directory name to convert
-@return absolute path (string)
+@type str
+@return absolute path
+@rtype str
 """
 if not os.path.isabs(fn):
 fn = os.path.join(self.ppath, fn)
 return fn
 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)
+@param fn file or directory name to convert
-@return absolute path (string)
+@type str
+@return absolute path
+@rtype str
 """
 if not os.path.isabs(fn):
 fn = os.path.join(self.ppath, FileSystemUtilities.toNativeSeparators(fn))
 return fn
 def getEolString(self):
 """
 Public method to get the EOL-string to be used by the project.
-@return eol string (string)
+@return eol string
+@rtype str
 """
 if self.__pdata["EOL"] >= 0:
 return self.eols[self.__pdata["EOL"]]
 else:
 eolMode = Preferences.getEditor("EOLMode")
 def useSystemEol(self):
 """
 Public method to check, if the project uses the system eol setting.
-@return flag indicating the usage of system eol (boolean)
+@return flag indicating the usage of system eol
+@rtype bool
 """
 return self.__pdata["EOL"] == 0
 def getProjectVersion(self):
 """
 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)
+@param fn filename to be checked
-@return flag indicating membership (boolean)
+@type str
+@return flag indicating membership
+@rtype bool
 """
 return any(
 self.__checkProjectFileGroup(fn, category)
 for category in self.getFileCategories()
 )
 def __checkProjectFileGroup(self, fn, group):
 """
 Private method to check, if a file is in a specific file group of the
 project.
-@param fn filename to be checked (string)
+@param fn filename to be checked
-@param group group to check (string)
+@type str
-@return flag indicating membership (boolean)
+@param group group to check
+@type str
+@return flag indicating membership
+@rtype bool
 """
 newfn = os.path.abspath(fn)
 newfn = self.getRelativePath(newfn)
 if newfn in self.__pdata[group] or (
 group == "OTHERS"
 self.actions.append(act)
 self.reloadAct = EricAction(
 self.tr("Reload project"),
 EricPixmapCache.getIcon("projectReload"),
-self.tr("&Reload"),
+self.tr("Re&load"),
 0,
 0,
 self.actGrp1,
 "project_reload",
 )
 """
 Public slot to initialize the project toolbar and the basic VCS
 toolbar.
 @param toolbarManager reference to a toolbar manager object
-(EricToolBarManager)
+@type EricToolBarManager
-@return tuple of the generated toolbars (tuple of two QToolBar)
+@return tuple of the generated toolbars
+@rtype tuple of two QToolBar
 """
 from eric7 import VCS
 tb = QToolBar(self.tr("Project"), self.ui)
 tb.setObjectName("ProjectToolbar")
 def __openRecent(self, act):
 """
 Private method to open a project from the list of rencently opened
 projects.
-@param act reference to the action that triggered (QAction)
+@param act reference to the action that triggered
+@type QAction
 """
 file = act.data()
 if file:
 self.openProject(file)
 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)
+be honoured
+@type bool
 @param onUserDemand flag indicating whether this method was
-requested by the user via a menu action (boolean)
+requested by the user via a menu action
+@type bool
 """
 from .AddFoundFilesDialog import AddFoundFilesDialog
 autoInclude = Preferences.getProject("AutoIncludeNewFiles")
 recursiveSearch = Preferences.getProject("SearchNewFilesRecursively")
 dirs.append(d)
 continue
 filetype = ""
 bfn = os.path.basename(fn)
-for pattern in sorted(self.__pdata["FILETYPES"].keys(), reverse=True):
+for pattern in sorted(self.__pdata["FILETYPES"], reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
 filetype = self.__pdata["FILETYPES"][pattern]
 break
 if (
 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 fn filename or directory name added
+@type str
 @param updateModel flag indicating an update of the model is requested
-(boolean)
+@type bool
 """
 self.projectFileAdded.emit(fn, "OTHERS")
 updateModel and self.__model.addNewItem("OTHERS", fn)
 def getActions(self):
 """
 Public method to get a list of all actions.
-@return list of all actions (list of EricAction)
+@return list of all actions
+@rtype list of EricAction
 """
 return self.actions[:]
 def addEricActions(self, actions):
 """
 Public method to add actions to the list of actions.
-@param actions list of actions (list of EricAction)
+@param actions list of actions
+@type list of EricAction
 """
 self.actions.extend(actions)
 def removeEricActions(self, actions):
 """
 Public method to remove actions from the list of actions.
-@param actions list of actions (list of EricAction)
+@param actions list of actions
+@type list of EricAction
 """
 for act in actions:
 with contextlib.suppress(ValueError):
 self.actions.remove(act)
 def getMenu(self, menuName):
 """
 Public method to get a reference to the main menu or a submenu.
-@param menuName name of the menu (string)
+@param menuName name of the menu
-@return reference to the requested menu (QMenu) or None
+@type str
+@return reference to the requested menu or None
+@rtype QMenu
 """
 try:
 return self.__menus[menuName]
 except KeyError:
 return None
 def repopulateItem(self, fullname):
 """
 Public slot to repopulate a named item.
-@param fullname full name of the item to repopulate (string)
+@param fullname full name of the item to repopulate
+@type str
 """
 if not self.isOpen():
 return
 with EricOverrideCursor():
 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 vcsSystem type of VCS to be used
+@type str
 @param nooverride flag indicating to ignore an override request
-(boolean)
+@type bool
 @return a reference to the vcs object
+@rtype VersionControl
 """
 from eric7 import VCS
 vcs = None
 forProject = True
 def vcsSoftwareAvailable(self):
 """
 Public method to check, if some supported VCS software is available
 to the IDE.
-@return flag indicating availability of VCS software (boolean)
+@return flag indicating availability of VCS software
+@rtype bool
 """
 vcsSystemsDict = (
 ericApp()
 .getObject("PluginManager")
 .getPluginDisplayStrings("version_control")
 def setStatusMonitorInterval(self, interval):
 """
 Public method to se the interval of the VCS status monitor thread.
-@param interval status monitor interval in seconds (integer)
+@param interval status monitor interval in seconds
+@type int
 """
 if self.vcs is not None:
 self.vcs.setStatusMonitorInterval(interval, self)
 def getStatusMonitorInterval(self):
 """
 Public method to get the monitor interval.
-@return interval in seconds (integer)
+@return interval in seconds
+@rtype int
 """
 if self.vcs is not None:
 return self.vcs.getStatusMonitorInterval()
 else:
 return 0
 def setStatusMonitorAutoUpdate(self, auto):
 """
 Public method to enable the auto update function.
-@param auto status of the auto update function (boolean)
+@param auto status of the auto update function
+@type bool
 """
 if self.vcs is not None:
 self.vcs.setStatusMonitorAutoUpdate(auto)
 def getStatusMonitorAutoUpdate(self):
 """
 Public method to retrieve the status of the auto update function.
-@return status of the auto update function (boolean)
+@return status of the auto update function
+@rtype bool
 """
 if self.vcs is not None:
 return self.vcs.getStatusMonitorAutoUpdate()
 else:
 return False
 def clearStatusMonitorCachedState(self, name):
 """
 Public method to clear the cached VCS state of a file/directory.
-@param name name of the entry to be cleared (string)
+@param name name of the entry to be cleared
+@type str
 """
 if self.vcs is not None:
 self.vcs.clearStatusMonitorCachedState(name)
 def startStatusMonitor(self):
 @pyqtSlot()
 def __pluginCreateArchives(self, snapshot=False):
 """
 Private slot to create eric plugin archives.
-@param snapshot flag indicating snapshot archives (boolean)
+@param snapshot flag indicating snapshot archives
+@type bool
 """
 if not self.__pdata["MAINSCRIPT"]:
 EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 def __createZipDirEntries(self, path, zipFile):
 """
 Private method to create dir entries in the zip file.
-@param path name of the directory entry to create (string)
+@param path name of the directory entry to create
-@param zipFile open ZipFile object (zipfile.ZipFile)
+@type str
+@param zipFile open ZipFile object
+@type zipfile.ZipFile
 """
 if path in ("", "/", "\\"):
 return
 if not path.endswith("/") and not path.endswith("\\"):
 The version entry in the plugin module is modified to signify
 a snapshot version. This method appends the string "-snapshot-"
 and date indicator to the version string.
-@param filename name of the plugin file to modify (string)
+@param filename name of the plugin file to modify
-@return modified source (bytes), snapshot version string (string)
+@type str
+@return modified source (bytes), snapshot version string
+@rtype str
 """
 try:
 sourcelines, encoding = Utilities.readEncodedFile(filename)
 sourcelines = sourcelines.splitlines(True)
 except (OSError, UnicodeError) as why:
 def __pluginExtractVersion(self, filename):
 """
 Private method to extract the version number entry.
-@param filename name of the plugin file (string)
+@param filename name of the plugin file
-@return version string (string)
+@type str
+@return version string
+@rtype str
 """
 version = "0.0.0"
 try:
 sourcelines = Utilities.readEncodedFile(filename)[0]
 sourcelines = sourcelines.splitlines(True)
 Public method to get a named uic related parameter.
 @param name name of the parameter
 @type str
 @return value of the given parameter
-@rtype any, None in case on non-existence
+@rtype Any, None in case on non-existence
 """
 if name in self.__pdata["UICPARAMS"]:
 return self.__pdata["UICPARAMS"][name]
 else:
 return None
 self.__venvConfiguration["system_site_packages"] = withSystemSitePackages
 self.__configureEnvironment()
 if not self.__venvConfiguration["interpreter"]:
 # user canceled the environment creation, delete the created directory
-shutil.rmtree(configuration["targetDirectory"], True)
+shutil.rmtree(configuration["targetDirectory"], ignore_errors=True)
 self.__setEmbeddedEnvironmentProjectConfig(False)
 return
 if upgrade and not withSystemSitePackages:
 # re-install the project into the upgraded environment

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py