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

-:6e260b424396
+:2b104ad132a4
 self.dbgGlobalConfigOverride = {
 "enable": False,
 "redirect": True,
 }
-self.pdata = {
+self.__pdata = {
 "DESCRIPTION": "",
 "VERSION": "",
 "SOURCES": [],
 "FORMS": [],
 "RESOURCES": [],
 "DOCSTRING": "",
 "TESTING_FRAMEWORK": "",
 "LICENSE": "",
 "EMBEDDED_VENV": False,
 }
+self.__knownFileCategories = [
+"FORMS",
+"OTHERS",
+"RESOURCES",
+"SOURCES",
+"TRANSLATIONS",
+"INTERFACES",
+"PROTOCOLS",
+]
 self.__initDebugProperties()
 self.pudata = {
 "VCSOVERRIDE": "",
 }
 self.vcs = self.initVCS()
 self.__initVenvConfiguration()
+def getProjectData(self, dataKey=None, default=None):
+"""
+Public method to get the data associated with the given data key.
+Note: If dataKey is None, a copy of the project data structure
+is returned.
+@param dataKey key of the data to get (defaults to None)
+@type str (optional)
+@param default default value for non-existent keys (defaults to None)
+@type Any (optional)
+@return requested data or None if the data key doesn't exist or
+a copy of the project data dictionary
+@rtype Any
+"""
+if dataKey is None:
+return copy.deepcopy(self.__pdata)
+try:
+return self.__pdata[dataKey]
+except KeyError:
+return default
+def setProjectData(self, data, dataKey=None):
+"""
+Public method to set data associated with the given data key in the project
+dictionary
+Note: If no data key is given or is None, the data must be a dictionary used
+to update the project data.
+@param data data to be set or a dictionary to update the project data
+@type Any
+@param dataKey key of the data to set (defaults to None)
+@type str (optional)
+"""
+if dataKey is None:
+self.__pdata.update(data)
+else:
+self.__pdata[dataKey] = data
+self.setDirty(True)
 def getData(self, category, key):
 """
 Public method to get data out of the project data store.
 "CHECKERSPARMS",
 "PACKAGERSPARMS",
 "DOCUMENTATIONPARMS",
 "OTHERTOOLSPARMS",
 ]
-and key in self.pdata[category]
+and key in self.__pdata[category]
 ):
-return copy.deepcopy(self.pdata[category][key])
+return copy.deepcopy(self.__pdata[category][key])
 else:
 return None
 def setData(self, category, key, data):
 """
 ]:
 return False
 # test for changes of data and save them in the project
 # 1. there were none, now there are
-if key not in self.pdata[category] and len(data) > 0:
+if key not in self.__pdata[category] and len(data) > 0:
-self.pdata[category][key] = copy.deepcopy(data)
+self.__pdata[category][key] = copy.deepcopy(data)
 self.setDirty(True)
 # 2. there were some, now there aren't
-elif key in self.pdata[category] and len(data) == 0:
+elif key in self.__pdata[category] and len(data) == 0:
-del self.pdata[category][key]
+del self.__pdata[category][key]
 self.setDirty(True)
 # 3. there were some and still are
-elif key in self.pdata[category] and len(data) > 0:
+elif key in self.__pdata[category] and len(data) > 0:
-if data != self.pdata[category][key]:
+if data != self.__pdata[category][key]:
-self.pdata[category][key] = copy.deepcopy(data)
+self.__pdata[category][key] = copy.deepcopy(data)
 self.setDirty(True)
 # 4. there were none and none are given
 else:
 return False
 return True
+def getFileCategories(self):
+"""
+Public method to get the list of known file categories.
+@return list of known file categories
+@rtype list of str
+"""
+return self.__knownFileCategories[:]
 def initFileTypes(self):
 """
 Public method to initialize the filetype associations with default
 values.
 """
-self.pdata["FILETYPES"] = {
+self.__pdata["FILETYPES"] = {
 "*.txt": "OTHERS",
 "*.md": "OTHERS",
 "*.rst": "OTHERS",
 "README": "OTHERS",
 "README.*": "OTHERS",
 "Makefile": "OTHERS",
 }
 # Sources
 sourceKey = (
-"Mixed" if self.pdata["MIXEDLANGUAGE"] else self.pdata["PROGLANGUAGE"]
+"Mixed" if self.__pdata["MIXEDLANGUAGE"] else self.__pdata["PROGLANGUAGE"]
 )
 for ext in self.__sourceExtensions(sourceKey):
-self.pdata["FILETYPES"]["*{0}".format(ext)] = "SOURCES"
+self.__pdata["FILETYPES"]["*{0}".format(ext)] = "SOURCES"
 # IDL interfaces
-self.pdata["FILETYPES"]["*.idl"] = "INTERFACES"
+self.__pdata["FILETYPES"]["*.idl"] = "INTERFACES"
 # Protobuf Files
-self.pdata["FILETYPES"]["*.proto"] = "PROTOCOLS"
+self.__pdata["FILETYPES"]["*.proto"] = "PROTOCOLS"
 # Forms
-if self.pdata["PROJECTTYPE"] in [
+if self.__pdata["PROJECTTYPE"] in [
 "E7Plugin",
 "PyQt5",
 "PyQt6",
 "PySide2",
 "PySide6",
 ]:
-self.pdata["FILETYPES"]["*.ui"] = "FORMS"
+self.__pdata["FILETYPES"]["*.ui"] = "FORMS"
 # Resources
-if self.pdata["PROJECTTYPE"] in [
+if self.__pdata["PROJECTTYPE"] in [
 "PyQt5",
 "PyQt5C",
 "PySide2",
 "PySide2C",
 "PySide6",
 "PySide6C",
 ]:
-self.pdata["FILETYPES"]["*.qrc"] = "RESOURCES"
+self.__pdata["FILETYPES"]["*.qrc"] = "RESOURCES"
 # Translations
-if self.pdata["PROJECTTYPE"] in [
+if self.__pdata["PROJECTTYPE"] in [
 "E7Plugin",
 "PyQt5",
 "PyQt5C",
 "PyQt6",
 "PyQt6C",
 "PySide2",
 "PySide2C",
 "PySide6",
 "PySide6C",
 ]:
-self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
+self.__pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
-self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
+self.__pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
 # Project type specific ones
 with contextlib.suppress(KeyError):
-if self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"]] is not None:
+if self.__fileTypeCallbacks[self.__pdata["PROJECTTYPE"]] is not None:
-ftypes = self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"]]()
+ftypes = self.__fileTypeCallbacks[self.__pdata["PROJECTTYPE"]]()
-self.pdata["FILETYPES"].update(ftypes)
+self.__pdata["FILETYPES"].update(ftypes)
 self.setDirty(True)
 def updateFileTypes(self):
 """
 Public method to update the filetype associations with new default
 values.
 """
-if self.pdata["PROJECTTYPE"] in [
+if self.__pdata["PROJECTTYPE"] in [
 "E7Plugin",
 "PyQt5",
 "PyQt5C",
 "PyQt6",
 "PyQt6C",
 "PySide2",
 "PySide2C",
 "PySide6",
 "PySide6C",
 ]:
-if "*.ts" not in self.pdata["FILETYPES"]:
+if "*.ts" not in self.__pdata["FILETYPES"]:
-self.pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
+self.__pdata["FILETYPES"]["*.ts"] = "TRANSLATIONS"
-if "*.qm" not in self.pdata["FILETYPES"]:
+if "*.qm" not in self.__pdata["FILETYPES"]:
-self.pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
+self.__pdata["FILETYPES"]["*.qm"] = "TRANSLATIONS"
 with contextlib.suppress(KeyError):
-if self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"]] is not None:
+if self.__fileTypeCallbacks[self.__pdata["PROJECTTYPE"]] is not None:
-ftypes = self.__fileTypeCallbacks[self.pdata["PROJECTTYPE"]]()
+ftypes = self.__fileTypeCallbacks[self.__pdata["PROJECTTYPE"]]()
 for pattern, ftype in list(ftypes.items()):
-if pattern not in self.pdata["FILETYPES"]:
+if pattern not in self.__pdata["FILETYPES"]:
-self.pdata["FILETYPES"][pattern] = ftype
+self.__pdata["FILETYPES"][pattern] = ftype
 self.setDirty(True)
 def __loadRecent(self):
 """
 Private method to load the recently opened project filenames.
 @param index key of the list to be checked (string)
 """
 removed = False
 removelist = []
-for file in self.pdata[index]:
+for file in self.__pdata[index]:
 if not os.path.exists(os.path.join(self.ppath, file)):
 removelist.append(file)
 removed = True
 if removed:
 for file in removelist:
-self.pdata[index].remove(file)
+self.__pdata[index].remove(file)
 self.setDirty(True)
 def __readProject(self, fn):
 """
 Private method to read in a project (.epj or .e4p) file.
 reader.readXML()
 res = not reader.hasError()
 f.close()
 # create hash value, if it doesn't have one
-if reader.version.startswith("5.") and not self.pdata["HASH"]:
+if reader.version.startswith("5.") and not self.__pdata["HASH"]:
 hashStr = str(
 QCryptographicHash.hash(
 QByteArray(self.ppath.encode("utf-8")),
 QCryptographicHash.Algorithm.Sha1,
 ).toHex(),
 encoding="utf-8",
 )
-self.pdata["HASH"] = hashStr
+self.__pdata["HASH"] = hashStr
 self.setDirty(True)
 else:
 EricMessageBox.critical(
 self.ui,
 self.tr("Read Project File"),
 self.ppath = os.path.abspath(os.path.dirname(fn))
 # insert filename into list of recently opened projects
 self.__syncRecent()
-if self.pdata["TRANSLATIONPATTERN"]:
+if self.__pdata["TRANSLATIONPATTERN"]:
-self.translationsRoot = self.pdata["TRANSLATIONPATTERN"].split(
+self.translationsRoot = self.__pdata["TRANSLATIONPATTERN"].split(
 "%language%"
 )[0]
-elif self.pdata["MAINSCRIPT"]:
+elif self.__pdata["MAINSCRIPT"]:
-self.translationsRoot = os.path.splitext(self.pdata["MAINSCRIPT"])[0]
+self.translationsRoot = os.path.splitext(self.__pdata["MAINSCRIPT"])[0]
 if os.path.isdir(os.path.join(self.ppath, self.translationsRoot)):
 dn = self.translationsRoot
 else:
 dn = os.path.dirname(self.translationsRoot)
 if dn not in self.subdirs:
 self.name = os.path.splitext(os.path.basename(fn))[0]
 # check, if the files of the project still exist in the
 # project directory
-self.__checkFilesExist("SOURCES")
+for fileCategory in self.__knownFileCategories:
-self.__checkFilesExist("FORMS")
+self.__checkFilesExist(fileCategory)
-self.__checkFilesExist("INTERFACES")
+##self.__checkFilesExist("SOURCES")
-self.__checkFilesExist("PROTOCOLS")
+##self.__checkFilesExist("FORMS")
-self.__checkFilesExist("TRANSLATIONS")
+##self.__checkFilesExist("INTERFACES")
-self.__checkFilesExist("RESOURCES")
+##self.__checkFilesExist("PROTOCOLS")
-self.__checkFilesExist("OTHERS")
+##self.__checkFilesExist("TRANSLATIONS")
+##self.__checkFilesExist("RESOURCES")
+##self.__checkFilesExist("OTHERS")
 # get the names of subdirectories the files are stored in
-for fn in (
+for fileCategory in [
-self.pdata["SOURCES"]
+c for c in self.__knownFileCategories if c != "OTHERS"
-+ self.pdata["FORMS"]
+]:
-+ self.pdata["INTERFACES"]
+for fn in self.__pdata[fileCategory]:
-+ self.pdata["PROTOCOLS"]
+##self.__pdata["SOURCES"]
-+ self.pdata["RESOURCES"]
+##+ self.__pdata["FORMS"]
-+ self.pdata["TRANSLATIONS"]
+##+ self.__pdata["INTERFACES"]
-):
+##+ self.__pdata["PROTOCOLS"]
-dn = os.path.dirname(fn)
+##+ self.__pdata["RESOURCES"]
-if dn not in self.subdirs:
+##+ self.__pdata["TRANSLATIONS"]
-self.subdirs.append(dn)
+##):
+dn = os.path.dirname(fn)
+if dn not in self.subdirs:
+self.subdirs.append(dn)
 # get the names of other subdirectories
-for fn in self.pdata["OTHERS"]:
+for fn in self.__pdata["OTHERS"]:
 dn = os.path.dirname(fn)
 if dn not in self.otherssubdirs:
 self.otherssubdirs.append(dn)
 return res
 is used instead of the one in the project object. This is the
 'save as' action.
 @return flag indicating success
 """
 if self.vcs is not None:
-self.pdata["VCSOPTIONS"] = copy.deepcopy(self.vcs.vcsGetOptions())
+self.__pdata["VCSOPTIONS"] = copy.deepcopy(self.vcs.vcsGetOptions())
-self.pdata["VCSOTHERDATA"] = copy.deepcopy(self.vcs.vcsGetOtherData())
+self.__pdata["VCSOTHERDATA"] = copy.deepcopy(self.vcs.vcsGetOtherData())
-if not self.pdata["HASH"]:
+if not self.__pdata["HASH"]:
 hashStr = str(
 QCryptographicHash.hash(
 QByteArray(self.ppath.encode("utf-8")),
 QCryptographicHash.Algorithm.Sha1,
 ).toHex(),
 encoding="utf-8",
 )
-self.pdata["HASH"] = hashStr
+self.__pdata["HASH"] = hashStr
 if fn is None:
 fn = self.pfile
 with EricOverrideCursor():
 """
 Public method to return the status of the debug properties.
 @return load status of debug properties (boolean)
 """
-return self.debugPropertiesLoaded or self.pdata["EMBEDDED_VENV"]
+return self.debugPropertiesLoaded or self.__pdata["EMBEDDED_VENV"]
 def __showDebugProperties(self):
 """
 Private slot to display the debugger properties dialog.
 """
 """
 Public method to get the translation pattern.
 @return translation pattern (string)
 """
-return self.pdata["TRANSLATIONPATTERN"]
+return self.__pdata["TRANSLATIONPATTERN"]
 def setTranslationPattern(self, pattern):
 """
 Public method to set the translation pattern.
 @param pattern translation pattern
 @type str
 """
-self.pdata["TRANSLATIONPATTERN"] = pattern
+self.__pdata["TRANSLATIONPATTERN"] = pattern
 def addLanguage(self):
 """
 Public slot used to add a language to the project.
 """
 from .AddLanguageDialog import AddLanguageDialog
-if not self.pdata["TRANSLATIONPATTERN"]:
+if not self.__pdata["TRANSLATIONPATTERN"]:
 EricMessageBox.critical(
 self.ui,
 self.tr("Add Language"),
 self.tr("You have to specify a translation pattern first."),
 )
 return
 dlg = AddLanguageDialog(self.parent())
 if dlg.exec() == QDialog.DialogCode.Accepted:
 lang = dlg.getSelectedLanguage()
-if self.pdata["PROJECTTYPE"] in [
+if self.__pdata["PROJECTTYPE"] in [
 "PyQt5",
 "PyQt5C",
 "PyQt6",
 "PyQt6C",
 "E7Plugin",
 "PySide2",
 "PySide2C",
 "PySide6",
 "PySide6C",
 ]:
-langFile = self.pdata["TRANSLATIONPATTERN"].replace("%language%", lang)
+langFile = self.__pdata["TRANSLATIONPATTERN"].replace(
+"%language%", lang
+)
 self.appendFile(langFile)
 self.projectLanguageAddedByCode.emit(lang)
 def __binaryTranslationFile(self, langFile):
 """
 @return name of the binary translations file (string)
 """
 qmFile = ""
 try:
 if (
-self.__binaryTranslationsCallbacks[self.pdata["PROJECTTYPE"]]
+self.__binaryTranslationsCallbacks[self.__pdata["PROJECTTYPE"]]
 is not None
 ):
-qmFile = self.__binaryTranslationsCallbacks[self.pdata["PROJECTTYPE"]](
+qmFile = self.__binaryTranslationsCallbacks[
-langFile
+self.__pdata["PROJECTTYPE"]
-)
+](langFile)
 except KeyError:
 qmFile = langFile.replace(".ts", ".qm")
 if qmFile == langFile:
 qmFile = ""
 return qmFile
 def checkLanguageFiles(self):
 """
 Public slot to check the language files after a release process.
 """
-tbPath = self.pdata["TRANSLATIONSBINPATH"]
+tbPath = self.__pdata["TRANSLATIONSBINPATH"]
-for langFile in self.pdata["TRANSLATIONS"][:]:
+for langFile in self.__pdata["TRANSLATIONS"][:]:
 qmFile = self.__binaryTranslationFile(langFile)
 if qmFile:
-if qmFile not in self.pdata["TRANSLATIONS"] and os.path.exists(
+if qmFile not in self.__pdata["TRANSLATIONS"] and os.path.exists(
 os.path.join(self.ppath, qmFile)
 ):
 self.appendFile(qmFile)
 if tbPath:
 qmFile = os.path.join(tbPath, os.path.basename(qmFile))
-if qmFile not in self.pdata["TRANSLATIONS"] and os.path.exists(
+if qmFile not in self.__pdata["TRANSLATIONS"] and os.path.exists(
 os.path.join(self.ppath, qmFile)
 ):
 self.appendFile(qmFile)
 def removeLanguageFile(self, langFile):
 @param langFile the translation file to be removed (string)
 """
 langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(langFile)
-self.pdata["TRANSLATIONS"].remove(langFile)
+self.__pdata["TRANSLATIONS"].remove(langFile)
 self.__model.removeItem(langFile)
 if qmFile:
 with contextlib.suppress(ValueError):
-if self.pdata["TRANSLATIONSBINPATH"]:
+if self.__pdata["TRANSLATIONSBINPATH"]:
 qmFile = self.getRelativePath(
 os.path.join(
-self.pdata["TRANSLATIONSBINPATH"], os.path.basename(qmFile)
+self.__pdata["TRANSLATIONSBINPATH"],
+os.path.basename(qmFile),
 )
 )
-self.pdata["TRANSLATIONS"].remove(qmFile)
+self.__pdata["TRANSLATIONS"].remove(qmFile)
 self.__model.removeItem(qmFile)
 self.setDirty(True)
 def deleteLanguageFile(self, langFile):
 """
 self.removeLanguageFile(langFile)
 # now get rid of the .qm file
 if qmFile:
 try:
-if self.pdata["TRANSLATIONSBINPATH"]:
+if self.__pdata["TRANSLATIONSBINPATH"]:
 qmFile = self.getRelativePath(
 os.path.join(
-self.pdata["TRANSLATIONSBINPATH"], os.path.basename(qmFile)
+self.__pdata["TRANSLATIONSBINPATH"],
+os.path.basename(qmFile),
 )
 )
 fn = os.path.join(self.ppath, qmFile)
 if os.path.exists(fn):
 s2t(fn)
 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"].keys(), reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
-filetype = self.pdata["FILETYPES"][pattern]
+filetype = self.__pdata["FILETYPES"][pattern]
 break
 if filetype == "__IGNORE__":
 return
+# TODO: change this logic to be more generic (use fileCategory)
 if filetype in ["SOURCES", "FORMS", "INTERFACES", "PROTOCOLS", "RESOURCES"]:
 if filetype == "SOURCES":
-if newfn not in self.pdata["SOURCES"]:
+if newfn not in self.__pdata["SOURCES"]:
-self.pdata["SOURCES"].append(newfn)
+self.__pdata["SOURCES"].append(newfn)
 self.projectSourceAdded.emit(newfn)
 updateModel and self.__model.addNewItem("SOURCES", newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 elif filetype == "FORMS":
-if newfn not in self.pdata["FORMS"]:
+if newfn not in self.__pdata["FORMS"]:
-self.pdata["FORMS"].append(newfn)
+self.__pdata["FORMS"].append(newfn)
 self.projectFormAdded.emit(newfn)
 updateModel and self.__model.addNewItem("FORMS", newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 elif filetype == "INTERFACES":
-if newfn not in self.pdata["INTERFACES"]:
+if newfn not in self.__pdata["INTERFACES"]:
-self.pdata["INTERFACES"].append(newfn)
+self.__pdata["INTERFACES"].append(newfn)
 self.projectInterfaceAdded.emit(newfn)
 (updateModel and self.__model.addNewItem("INTERFACES", newfn))
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 elif filetype == "PROTOCOLS":
-if newfn not in self.pdata["PROTOCOLS"]:
+if newfn not in self.__pdata["PROTOCOLS"]:
-self.pdata["PROTOCOLS"].append(newfn)
+self.__pdata["PROTOCOLS"].append(newfn)
 self.projectProtocolAdded.emit(newfn)
 (updateModel and self.__model.addNewItem("PROTOCOLS", newfn))
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 elif filetype == "RESOURCES":
-if newfn not in self.pdata["RESOURCES"]:
+if newfn not in self.__pdata["RESOURCES"]:
-self.pdata["RESOURCES"].append(newfn)
+self.__pdata["RESOURCES"].append(newfn)
 self.projectResourceAdded.emit(newfn)
 updateModel and self.__model.addNewItem("RESOURCES", newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 if newdir not in self.subdirs:
 self.subdirs.append(newdir)
 elif filetype == "TRANSLATIONS":
-if newfn not in self.pdata["TRANSLATIONS"]:
+if newfn not in self.__pdata["TRANSLATIONS"]:
-self.pdata["TRANSLATIONS"].append(newfn)
+self.__pdata["TRANSLATIONS"].append(newfn)
 updateModel and self.__model.addNewItem("TRANSLATIONS", newfn)
 self.projectLanguageAdded.emit(newfn)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 else:  # filetype == "OTHERS"
-if newfn not in self.pdata["OTHERS"]:
+if newfn not in self.__pdata["OTHERS"]:
-self.pdata["OTHERS"].append(newfn)
+self.__pdata["OTHERS"].append(newfn)
 self.othersAdded(newfn, updateModel)
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
 if newdir not in self.otherssubdirs:
 @param quiet flag indicating quiet operations (boolean)
 """
 # get all relevant filename patterns
 patterns = []
 ignorePatterns = []
-for pattern, patterntype in list(self.pdata["FILETYPES"].items()):
+for pattern, patterntype in list(self.__pdata["FILETYPES"].items()):
 if patterntype == filetype:
 patterns.append(pattern)
 elif patterntype == "__IGNORE__":
 ignorePatterns.append(pattern)
 # first perform the addition of source
 self.__addSingleDirectory(filetype, source, target, True)
 ignore_patterns = [
 pattern
-for pattern, filetype in self.pdata["FILETYPES"].items()
+for pattern, filetype in self.__pdata["FILETYPES"].items()
 if filetype == "__IGNORE__"
 ]
 # now recurse into subdirectories
 for name in os.listdir(source):
 # if it ends with the directory separator character, remove it
 if fn.endswith(os.sep):
 fn = fn[:-1]
-if fn not in self.pdata["OTHERS"]:
+if fn not in self.__pdata["OTHERS"]:
-self.pdata["OTHERS"].append(fn)
+self.__pdata["OTHERS"].append(fn)
 self.othersAdded(fn)
 self.setDirty(True)
 if os.path.isdir(fn) and fn not in self.otherssubdirs:
 self.otherssubdirs.append(fn)
 Public method to rename the main script.
 @param oldfn old filename (string)
 @param newfn new filename of the main script (string)
 """
-if self.pdata["MAINSCRIPT"]:
+if self.__pdata["MAINSCRIPT"]:
 ofn = self.getRelativePath(oldfn)
-if ofn != self.pdata["MAINSCRIPT"]:
+if ofn != self.__pdata["MAINSCRIPT"]:
 return
 fn = self.getRelativePath(newfn)
-self.pdata["MAINSCRIPT"] = fn
+self.__pdata["MAINSCRIPT"] = fn
 self.setDirty(True)
 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)
 @return flag indicating success
 """
 fn = self.getRelativePath(oldfn)
-isSourceFile = fn in self.pdata["SOURCES"]
+isSourceFile = fn in self.__pdata["SOURCES"]
 if newfn is None:
 newfn = EricFileDialog.getSaveFileName(
 None,
 self.tr("Rename file"),
 """Reason: {1}</p>"""
 ).format(oldfn, str(msg)),
 )
 return False
-if (
+##if (
-fn in self.pdata["SOURCES"]
+##fn in self.__pdata["SOURCES"]
-or fn in self.pdata["FORMS"]
+##or fn in self.__pdata["FORMS"]
-or fn in self.pdata["TRANSLATIONS"]
+##or fn in self.__pdata["TRANSLATIONS"]
-or fn in self.pdata["INTERFACES"]
+##or fn in self.__pdata["INTERFACES"]
-or fn in self.pdata["PROTOCOLS"]
+##or fn in self.__pdata["PROTOCOLS"]
-or fn in self.pdata["RESOURCES"]
+##or fn in self.__pdata["RESOURCES"]
-or fn in self.pdata["OTHERS"]
+##or fn in self.__pdata["OTHERS"]
-):
+##):
+if any(fn in self.__pdata[category] for category in self.__knownFileCategories):
 self.renameFileInPdata(oldfn, newfn, isSourceFile)
 return True
 def renameFileInPdata(self, oldname, newname, isSourceFile=False):
 """
-Public method to rename a file in the pdata structure.
+Public method to rename a file in the __pdata structure.
 @param oldname old filename (string)
 @param newname new filename (string)
 @param isSourceFile flag indicating that this is a source file
 even if it doesn't have the source extension (boolean)
 @param start prefix (string)
 @return list of files starting with a common prefix (list of strings)
 """
 filelist = []
 start = self.getRelativePath(start)
-for key in [
+##for key in [
-"SOURCES",
+##"SOURCES",
-"FORMS",
+##"FORMS",
-"INTERFACES",
+##"INTERFACES",
-"PROTOCOLS",
+##"PROTOCOLS",
-"RESOURCES",
+##"RESOURCES",
-"OTHERS",
+##"OTHERS",
+##]:
+for fileCategory in [
+c for c in self.__knownFileCategories if c != "TRANSLATIONS"
 ]:
-for entry in self.pdata[key][:]:
+for entry in self.__pdata[fileCategory][:]:
 if entry.startswith(start):
 filelist.append(os.path.join(self.ppath, entry))
 return filelist
 def __reorganizeFiles(self):
 """
 reorganized = False
 # init data store for the reorganization
 newPdata = {}
-for key in [
+##for key in [
-"SOURCES",
+##"SOURCES",
-"FORMS",
+##"FORMS",
-"INTERFACES",
+##"INTERFACES",
-"PROTOCOLS",
+##"PROTOCOLS",
-"RESOURCES",
+##"RESOURCES",
-"OTHERS",
+##"OTHERS",
-"TRANSLATIONS",
+##"TRANSLATIONS",
-]:
+##]:
-newPdata[key] = []
+for fileCategory in self.__knownFileCategories:
+newPdata[fileCategory] = []
 # iterate over all files checking for a reassignment
-for key in [
+##for key in [
-"SOURCES",
+##"SOURCES",
-"FORMS",
+##"FORMS",
-"INTERFACES",
+##"INTERFACES",
-"PROTOCOLS",
+##"PROTOCOLS",
-"RESOURCES",
+##"RESOURCES",
-"OTHERS",
+##"OTHERS",
-"TRANSLATIONS",
+##"TRANSLATIONS",
-]:
+##]:
-for fn in self.pdata[key][:]:
+for fileCategory in self.__knownFileCategories:
-filetype = key
+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"].keys(), reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
-filetype = self.pdata["FILETYPES"][pattern]
+filetype = self.__pdata["FILETYPES"][pattern]
 break
 if filetype != "__IGNORE__":
 newPdata[filetype].append(fn)
-if filetype != key:
+if filetype != fileCategory:
 reorganized = True
 if reorganized:
 # copy the reorganized files back to the project
-for key in [
+##for key in [
-"SOURCES",
+##"SOURCES",
-"FORMS",
+##"FORMS",
-"INTERFACES",
+##"INTERFACES",
-"PROTOCOLS",
+##"PROTOCOLS",
-"RESOURCES",
+##"RESOURCES",
-"OTHERS",
+##"OTHERS",
-"TRANSLATIONS",
+##"TRANSLATIONS",
-]:
+##]:
-self.pdata[key] = newPdata[key][:]
+for fileCategory in self.__knownFileCategories:
+self.__pdata[fileCategory] = newPdata[fileCategory][:]
 # repopulate the model
 self.__model.projectClosed(False)
 self.__model.projectOpened()
 @param olddn original directory name (string)
 @param newdn new directory name (string)
 """
 olddn = self.getRelativePath(olddn)
 newdn = self.getRelativePath(newdn)
-for key in [
+##for key in [
-"SOURCES",
+##"SOURCES",
-"FORMS",
+##"FORMS",
-"INTERFACES",
+##"INTERFACES",
-"PROTOCOLS",
+##"PROTOCOLS",
-"RESOURCES",
+##"RESOURCES",
-"OTHERS",
+##"OTHERS",
+##]:
+for fileCategory in [
+c for c in self.__knownFileCategories if c != "TRANSLATIONS"
 ]:
-for entry in self.pdata[key][:]:
+for entry in self.__pdata[fileCategory][:]:
 if entry.startswith(olddn):
 entry = entry.replace(olddn, newdn)
-self.appendFile(os.path.join(self.ppath, entry), key == "SOURCES")
+self.appendFile(
+os.path.join(self.ppath, entry), fileCategory == "SOURCES"
+)
 self.setDirty(True)
 def moveDirectory(self, olddn, newdn):
 """
 Public slot to move a directory.
 @param newdn new directory name (string)
 """
 olddn = self.getRelativePath(olddn)
 newdn = self.getRelativePath(newdn)
 typeStrings = []
-for key in [
+##for key in [
-"SOURCES",
+##"SOURCES",
-"FORMS",
+##"FORMS",
-"INTERFACES",
+##"INTERFACES",
-"PROTOCOLS",
+##"PROTOCOLS",
-"RESOURCES",
+##"RESOURCES",
-"OTHERS",
+##"OTHERS",
+##]:
+for fileCategory in [
+c for c in self.__knownFileCategories if c != "TRANSLATIONS"
 ]:
-for entry in self.pdata[key][:]:
+for entry in self.__pdata[fileCategory][:]:
 if entry.startswith(olddn):
-if key not in typeStrings:
+if fileCategory not in typeStrings:
-typeStrings.append(key)
+typeStrings.append(fileCategory)
-self.pdata[key].remove(entry)
+self.__pdata[fileCategory].remove(entry)
 entry = entry.replace(olddn, newdn)
-self.pdata[key].append(entry)
+self.__pdata[fileCategory].append(entry)
-if key == "OTHERS":
+if fileCategory == "OTHERS":
 if newdn not in self.otherssubdirs:
 self.otherssubdirs.append(newdn)
 else:
 if newdn not in self.subdirs:
 self.subdirs.append(newdn)
 @param updateModel flag indicating an update of the model is
 requested (boolean)
 """
 fn = self.getRelativePath(fn)
 dirty = True
-if fn in self.pdata["SOURCES"]:
+# TODO: change this logic to be more generic (use fileCategory)
-self.pdata["SOURCES"].remove(fn)
+if fn in self.__pdata["SOURCES"]:
+self.__pdata["SOURCES"].remove(fn)
 self.projectSourceRemoved.emit(fn)
-elif fn in self.pdata["FORMS"]:
+elif fn in self.__pdata["FORMS"]:
-self.pdata["FORMS"].remove(fn)
+self.__pdata["FORMS"].remove(fn)
 self.projectFormRemoved.emit(fn)
-elif fn in self.pdata["INTERFACES"]:
+elif fn in self.__pdata["INTERFACES"]:
-self.pdata["INTERFACES"].remove(fn)
+self.__pdata["INTERFACES"].remove(fn)
 self.projectInterfaceRemoved.emit(fn)
-elif fn in self.pdata["PROTOCOLS"]:
+elif fn in self.__pdata["PROTOCOLS"]:
-self.pdata["PROTOCOLS"].remove(fn)
+self.__pdata["PROTOCOLS"].remove(fn)
 self.projectProtocolRemoved.emit(fn)
-elif fn in self.pdata["RESOURCES"]:
+elif fn in self.__pdata["RESOURCES"]:
-self.pdata["RESOURCES"].remove(fn)
+self.__pdata["RESOURCES"].remove(fn)
 self.projectResourceRemoved.emit(fn)
-elif fn in self.pdata["OTHERS"]:
+elif fn in self.__pdata["OTHERS"]:
-self.pdata["OTHERS"].remove(fn)
+self.__pdata["OTHERS"].remove(fn)
 self.projectOthersRemoved.emit(fn)
-elif fn in self.pdata["TRANSLATIONS"]:
+elif fn in self.__pdata["TRANSLATIONS"]:
-self.pdata["TRANSLATIONS"].remove(fn)
+self.__pdata["TRANSLATIONS"].remove(fn)
 self.projectLanguageRemoved.emit(fn)
 else:
 dirty = False
 updateModel and self.__model.removeItem(fn)
 if dirty:
 @param dn directory name to be removed from the project
 """
 dirty = False
 dn = self.getRelativePath(dn)
-for entry in self.pdata["OTHERS"][:]:
+for entry in self.__pdata["OTHERS"][:]:
 if entry.startswith(dn):
-self.pdata["OTHERS"].remove(entry)
+self.__pdata["OTHERS"].remove(entry)
 dirty = True
 dn2 = dn if dn.endswith(os.sep) else dn + os.sep
-for key in [
+##for key in [
-"SOURCES",
+##"SOURCES",
-"FORMS",
+##"FORMS",
-"INTERFACES",
+##"INTERFACES",
-"PROTOCOLS",
+##"PROTOCOLS",
-"RESOURCES",
+##"RESOURCES",
-"TRANSLATIONS",
+##"TRANSLATIONS",
-]:
+##]:
-for entry in self.pdata[key][:]:
+for fileCategory in [c for c in self.__knownFileCategories if c != "OTHERS"]:
+for entry in self.__pdata[fileCategory][:]:
 if entry.startswith(dn2):
-self.pdata[key].remove(entry)
+self.__pdata[fileCategory].remove(entry)
 dirty = True
 self.__model.removeItem(dn)
 if dirty:
 self.setDirty(True)
 self.directoryRemoved.emit(dn)
 @param fn filename to be checked (string)
 @return flag indicating, if the project contains the file (boolean)
 """
 fn = self.getRelativePath(fn)
-return (
+return any(
-fn in self.pdata["SOURCES"]
+fn in self.__pdata[category]
-or fn in self.pdata["FORMS"]
+for category in self.__knownFileCategories
-or fn in self.pdata["INTERFACES"]
+if category != "TRANSLATIONS"
-or fn in self.pdata["PROTOCOLS"]
+)
-or fn in self.pdata["RESOURCES"]
+##fn in self.__pdata["SOURCES"]
-or fn in self.pdata["OTHERS"]
+##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"]
+##)
 def createNewProject(self):
 """
 Public slot to built a new project.
 dlg = PropertiesDialog(self, True)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 self.closeProject()
 dlg.storeData()
-self.pdata["VCS"] = "None"
+self.__pdata["VCS"] = "None"
 self.opened = True
-if not self.pdata["FILETYPES"]:
+if not self.__pdata["FILETYPES"]:
 self.initFileTypes()
 self.setDirty(True)
 self.closeAct.setEnabled(True)
 self.saveasAct.setEnabled(True)
 self.actGrp2.setEnabled(True)
 self.menuCheckAct.setEnabled(True)
 self.menuShowAct.setEnabled(True)
 self.menuDiagramAct.setEnabled(True)
 self.menuApidocAct.setEnabled(True)
 self.menuPackagersAct.setEnabled(True)
-self.pluginGrp.setEnabled(self.pdata["PROJECTTYPE"] in ["E7Plugin"])
+self.pluginGrp.setEnabled(self.__pdata["PROJECTTYPE"] in ["E7Plugin"])
-self.addLanguageAct.setEnabled(bool(self.pdata["TRANSLATIONPATTERN"]))
+self.addLanguageAct.setEnabled(bool(self.__pdata["TRANSLATIONPATTERN"]))
-self.makeGrp.setEnabled(self.pdata["MAKEPARAMS"]["MakeEnabled"])
+self.makeGrp.setEnabled(self.__pdata["MAKEPARAMS"]["MakeEnabled"])
-self.menuMakeAct.setEnabled(self.pdata["MAKEPARAMS"]["MakeEnabled"])
+self.menuMakeAct.setEnabled(self.__pdata["MAKEPARAMS"]["MakeEnabled"])
 self.menuOtherToolsAct.setEnabled(True)
 self.menuFormattingAct.setEnabled(True)
 self.projectAboutToBeCreated.emit()
 QByteArray(self.ppath.encode("utf-8")),
 QCryptographicHash.Algorithm.Sha1,
 ).toHex(),
 encoding="utf-8",
 )
-self.pdata["HASH"] = hashStr
+self.__pdata["HASH"] = hashStr
-if self.pdata["PROGLANGUAGE"] == "MicroPython":
+if self.__pdata["PROGLANGUAGE"] == "MicroPython":
 # change the lexer association for *.py files
-self.pdata["LEXERASSOCS"] = {
+self.__pdata["LEXERASSOCS"] = {
 "*.py": "MicroPython",
 }
 # create the project directory if it doesn't exist already
 if not os.path.isdir(self.ppath):
 self.vcs = self.initVCS()
 return
 # create an empty __init__.py file to make it a Python package
 # (only for Python and Python3)
-if self.pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]:
+if self.__pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]:
 fn = os.path.join(self.ppath, "__init__.py")
 with open(fn, "w", encoding="utf-8"):
 pass
 self.appendFile(fn, True)
 # create an empty main script file, if a name was given
-if self.pdata["MAINSCRIPT"]:
+if self.__pdata["MAINSCRIPT"]:
-if not os.path.isabs(self.pdata["MAINSCRIPT"]):
+if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
-ms = os.path.join(self.ppath, self.pdata["MAINSCRIPT"])
+ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 else:
-ms = self.pdata["MAINSCRIPT"]
+ms = self.__pdata["MAINSCRIPT"]
 os.makedirs(os.path.dirname(ms), exist_ok=True)
 with open(ms, "w"):
 pass
 self.appendFile(ms, True)
-if self.pdata["MAKEPARAMS"]["MakeEnabled"]:
+if self.__pdata["MAKEPARAMS"]["MakeEnabled"]:
-mf = self.pdata["MAKEPARAMS"]["MakeFile"]
+mf = self.__pdata["MAKEPARAMS"]["MakeFile"]
 if mf:
 if not os.path.isabs(mf):
 mf = os.path.join(self.ppath, mf)
 else:
 mf = os.path.join(self.ppath, Project.DefaultMakefile)
 tpd = os.path.join(self.ppath, self.translationsRoot)
 if not self.translationsRoot.endswith(os.sep):
 tpd = os.path.dirname(tpd)
 if not os.path.isdir(tpd):
 os.makedirs(tpd, exist_ok=True)
-if self.pdata["TRANSLATIONSBINPATH"]:
+if self.__pdata["TRANSLATIONSBINPATH"]:
-tpd = os.path.join(self.ppath, self.pdata["TRANSLATIONSBINPATH"])
+tpd = os.path.join(self.ppath, self.__pdata["TRANSLATIONSBINPATH"])
 if not os.path.isdir(tpd):
 os.makedirs(tpd, exist_ok=True)
 # create management directory if not present
 self.createProjectManagementDir()
 " writable.</p>"
 ).format(self.ppath),
 )
 return
-if self.pdata["MAINSCRIPT"]:
+if self.__pdata["MAINSCRIPT"]:
-if not os.path.isabs(self.pdata["MAINSCRIPT"]):
+if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
-ms = os.path.join(self.ppath, self.pdata["MAINSCRIPT"])
+ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 else:
-ms = self.pdata["MAINSCRIPT"]
+ms = self.__pdata["MAINSCRIPT"]
 if not os.path.exists(ms):
 try:
 os.makedirs(os.path.dirname(ms))
 with open(ms, "w"):
 pass
 )
 self.appendFile(ms, True)
 else:
 ms = ""
-if self.pdata["MAKEPARAMS"]["MakeEnabled"]:
+if self.__pdata["MAKEPARAMS"]["MakeEnabled"]:
-mf = self.pdata["MAKEPARAMS"]["MakeFile"]
+mf = self.__pdata["MAKEPARAMS"]["MakeFile"]
 if mf:
 if not os.path.isabs(mf):
 mf = os.path.join(self.ppath, mf)
 else:
 mf = os.path.join(self.ppath, Project.DefaultMakefile)
 if res:
 self.newProjectAddFiles(ms)
 addAllToVcs = res
 # create an empty __init__.py file to make it a Python package
 # if none exists (only for Python and Python3)
-if self.pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]:
+if self.__pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]:
 fn = os.path.join(self.ppath, "__init__.py")
 if not os.path.exists(fn):
 with open(fn, "w", encoding="utf-8"):
 pass
 self.appendFile(fn, True)
 vcsSystem = "None"
 else:
 vcsSystem = "None"
 else:
 vcsSystem = vcsData[0][1]
-self.pdata["VCS"] = vcsSystem
+self.__pdata["VCS"] = vcsSystem
 self.vcs = self.initVCS()
 self.setDirty(True)
 if self.vcs is not None:
 # edit VCS command options
 if self.vcs.vcsSupportCommandOptions():
 )
 if apres:
 self.saveProject()
 self.vcs.vcsAdd(self.pfile)
 else:
-self.pdata["VCS"] = "None"
+self.__pdata["VCS"] = "None"
 self.saveProject()
 break
 # put the project under VCS control
 if self.vcs is None and self.vcsSoftwareAvailable() and self.vcsRequested:
 False,
 )
 if ok and vcsSelected != self.tr("None"):
 for vcsSystem, vcsSystemDisplay in vcsSystemsDict.items():
 if vcsSystemDisplay == vcsSelected:
-self.pdata["VCS"] = vcsSystem
+self.__pdata["VCS"] = vcsSystem
 break
 else:
-self.pdata["VCS"] = "None"
+self.__pdata["VCS"] = "None"
 else:
-self.pdata["VCS"] = "None"
+self.__pdata["VCS"] = "None"
 self.vcs = self.initVCS()
 if self.vcs is not None:
 vcsdlg = self.vcs.vcsOptionsDialog(self, self.name)
 if vcsdlg.exec() == QDialog.DialogCode.Accepted:
 vcsDataDict = vcsdlg.getData()
 else:
-self.pdata["VCS"] = "None"
+self.__pdata["VCS"] = "None"
 self.vcs = self.initVCS()
 self.setDirty(True)
 if self.vcs is not None:
 # edit VCS command options
 if self.vcs.vcsSupportCommandOptions():
 else:
 self.newProjectHooks.emit()
 self.newProject.emit()
-if self.pdata["EMBEDDED_VENV"]:
+if self.__pdata["EMBEDDED_VENV"]:
 self.__createEmbeddedEnvironment()
-self.menuEnvironmentAct.setEnabled(self.pdata["EMBEDDED_VENV"])
+self.menuEnvironmentAct.setEnabled(self.__pdata["EMBEDDED_VENV"])
 def newProjectAddFiles(self, mainscript):
 """
 Public method to add files to a new project.
 # Show the file type associations for the user to change
 self.__showFiletypeAssociations()
 with EricOverrideCursor():
 # search the project directory for files with known extensions
-filespecs = list(self.pdata["FILETYPES"].keys())
+filespecs = list(self.__pdata["FILETYPES"].keys())
 for filespec in filespecs:
 files = Utilities.direntries(self.ppath, True, filespec)
 for file in files:
 self.appendFile(file)
 if not self.translationsRoot.endswith(os.sep):
 tpd = os.path.dirname(tpd)
 else:
 tpd = self.ppath
 tslist = []
-if self.pdata["TRANSLATIONPATTERN"]:
+if self.__pdata["TRANSLATIONPATTERN"]:
-pattern = os.path.basename(self.pdata["TRANSLATIONPATTERN"])
+pattern = os.path.basename(self.__pdata["TRANSLATIONPATTERN"])
 if "%language%" in pattern:
 pattern = pattern.replace("%language%", "*")
 else:
-tpd = self.pdata["TRANSLATIONPATTERN"].split("%language%")[0]
+tpd = self.__pdata["TRANSLATIONPATTERN"].split("%language%")[0]
 else:
 pattern = "*.ts"
 tslist.extend(Utilities.direntries(tpd, True, pattern))
 pattern = self.__binaryTranslationFile(pattern)
 if pattern:
 # 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(
+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],
 ),
 ),
 QLineEdit.EchoMode.Normal,
 tslist[0],
 )
 if pattern:
-self.pdata["TRANSLATIONPATTERN"] = pattern
+self.__pdata["TRANSLATIONPATTERN"] = pattern
-if self.pdata["TRANSLATIONPATTERN"]:
+if self.__pdata["TRANSLATIONPATTERN"]:
-self.pdata["TRANSLATIONPATTERN"] = self.getRelativePath(
+self.__pdata["TRANSLATIONPATTERN"] = self.getRelativePath(
-self.pdata["TRANSLATIONPATTERN"]
+self.__pdata["TRANSLATIONPATTERN"]
 )
-pattern = self.pdata["TRANSLATIONPATTERN"].replace(
+pattern = self.__pdata["TRANSLATIONPATTERN"].replace(
 "%language%", "*"
 )
 for ts in tslist:
 if fnmatch.fnmatch(ts, pattern):
-self.pdata["TRANSLATIONS"].append(ts)
+self.__pdata["TRANSLATIONS"].append(ts)
 self.projectLanguageAdded.emit(ts)
-if self.pdata["TRANSLATIONSBINPATH"]:
+if self.__pdata["TRANSLATIONSBINPATH"]:
 tpd = os.path.join(
-self.ppath, self.pdata["TRANSLATIONSBINPATH"]
+self.ppath, self.__pdata["TRANSLATIONSBINPATH"]
 )
 pattern = os.path.basename(
-self.pdata["TRANSLATIONPATTERN"]
+self.__pdata["TRANSLATIONPATTERN"]
 ).replace("%language%", "*")
 pattern = self.__binaryTranslationFile(pattern)
 qmlist = Utilities.direntries(tpd, True, pattern)
 for qm in qmlist:
-self.pdata["TRANSLATIONS"].append(qm)
+self.__pdata["TRANSLATIONS"].append(qm)
 self.projectLanguageAdded.emit(qm)
-if not self.pdata["MAINSCRIPT"] and bool(mainscriptname):
+if not self.__pdata["MAINSCRIPT"] and bool(mainscriptname):
-if self.pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]:
+if self.__pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]:
-self.pdata["MAINSCRIPT"] = "{0}.py".format(mainscriptname)
+self.__pdata["MAINSCRIPT"] = "{0}.py".format(mainscriptname)
-elif self.pdata["PROGLANGUAGE"] == "Ruby":
+elif self.__pdata["PROGLANGUAGE"] == "Ruby":
-self.pdata["MAINSCRIPT"] = "{0}.rb".format(mainscriptname)
+self.__pdata["MAINSCRIPT"] = "{0}.rb".format(mainscriptname)
 self.setDirty(True)
 def __showProperties(self):
 """
 Private slot to display the properties dialog.
 """
 from .PropertiesDialog import PropertiesDialog
 dlg = PropertiesDialog(self, False)
 if dlg.exec() == QDialog.DialogCode.Accepted:
-projectType = self.pdata["PROJECTTYPE"]
+projectType = self.__pdata["PROJECTTYPE"]
 dlg.storeData()
 self.setDirty(True)
-if self.pdata["MAINSCRIPT"]:
+if self.__pdata["MAINSCRIPT"]:
-if not os.path.isabs(self.pdata["MAINSCRIPT"]):
+if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
-ms = os.path.join(self.ppath, self.pdata["MAINSCRIPT"])
+ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 else:
-ms = self.pdata["MAINSCRIPT"]
+ms = self.__pdata["MAINSCRIPT"]
 if os.path.exists(ms):
 self.appendFile(ms)
-if self.pdata["MAKEPARAMS"]["MakeEnabled"]:
+if self.__pdata["MAKEPARAMS"]["MakeEnabled"]:
-mf = self.pdata["MAKEPARAMS"]["MakeFile"]
+mf = self.__pdata["MAKEPARAMS"]["MakeFile"]
 if mf:
 if not os.path.isabs(mf):
 mf = os.path.join(self.ppath, mf)
 else:
 mf = os.path.join(self.ppath, Project.DefaultMakefile)
 " be created.<br/>Reason: {1}</p>"
 ).format(mf, str(err)),
 )
 self.appendFile(mf)
-if self.pdata["PROJECTTYPE"] != projectType:
+if self.__pdata["PROJECTTYPE"] != projectType:
 # reinitialize filetype associations
 self.initFileTypes()
 if self.translationsRoot:
 tp = os.path.join(self.ppath, self.translationsRoot)
 if not os.path.isdir(tp):
 os.makedirs(tp)
 if tp != self.ppath and tp not in self.subdirs:
 self.subdirs.append(tp)
-if self.pdata["TRANSLATIONSBINPATH"]:
+if self.__pdata["TRANSLATIONSBINPATH"]:
-tp = os.path.join(self.ppath, self.pdata["TRANSLATIONSBINPATH"])
+tp = os.path.join(self.ppath, self.__pdata["TRANSLATIONSBINPATH"])
 if not os.path.isdir(tp):
 os.makedirs(tp)
 if tp != self.ppath and tp not in self.subdirs:
 self.subdirs.append(tp)
-self.pluginGrp.setEnabled(self.pdata["PROJECTTYPE"] in ["E7Plugin"])
+self.pluginGrp.setEnabled(self.__pdata["PROJECTTYPE"] in ["E7Plugin"])
 self.__model.projectPropertiesChanged()
 self.projectPropertiesChanged.emit()
-if self.pdata["PROJECTTYPE"] != projectType:
+if self.__pdata["PROJECTTYPE"] != projectType:
 self.__reorganizeFiles()
-if self.pdata["EMBEDDED_VENV"] and not self.__findEmbeddedEnvironment():
+if self.__pdata["EMBEDDED_VENV"] and not self.__findEmbeddedEnvironment():
 self.__createEmbeddedEnvironment()
 def __showUserProperties(self):
 """
 Private slot to display the user specific properties dialog.
 """
 from .UserPropertiesDialog import UserPropertiesDialog
-vcsSystem = self.pdata["VCS"] or None
+vcsSystem = self.__pdata["VCS"] or None
 vcsSystemOverride = self.pudata["VCSOVERRIDE"] or None
 dlg = UserPropertiesDialog(self)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 dlg.storeData()
 if (
-(self.pdata["VCS"] and self.pdata["VCS"] != vcsSystem)
+(self.__pdata["VCS"] and self.__pdata["VCS"] != vcsSystem)
 or (
 self.pudata["VCSOVERRIDE"]
 and self.pudata["VCSOVERRIDE"] != vcsSystemOverride
 )
 or (vcsSystemOverride is not None and not self.pudata["VCSOVERRIDE"])
 @return list of file patterns for the given type
 @rtype list of str
 """
 return [
 assoc
-for assoc in self.pdata["FILETYPES"]
+for assoc in self.__pdata["FILETYPES"]
-if self.pdata["FILETYPES"][assoc] == associationType
+if self.__pdata["FILETYPES"][assoc] == associationType
 ]
 def __showLexerAssociations(self):
 """
 Private slot to display the lexer association dialog.
 @param filename filename used to determine the associated lexer
 language (string)
 @return the requested lexer language (string)
 """
 # try user settings first
-for pattern, language in list(self.pdata["LEXERASSOCS"].items()):
+for pattern, language in list(self.__pdata["LEXERASSOCS"].items()):
 if fnmatch.fnmatch(filename, pattern):
 return language
 # try project type specific defaults next
-projectType = self.pdata["PROJECTTYPE"]
+projectType = self.__pdata["PROJECTTYPE"]
 with contextlib.suppress(KeyError):
 if self.__lexerAssociationCallbacks[projectType] is not None:
 return self.__lexerAssociationCallbacks[projectType](filename)
 # return empty string to signal to use the global setting
 if fn and self.closeProject():
 with EricOverrideCursor():
 ok = self.__readProject(fn)
 if ok:
 self.opened = True
-if not self.pdata["FILETYPES"]:
+if not self.__pdata["FILETYPES"]:
 self.initFileTypes()
 else:
 self.updateFileTypes()
 try:
 vcsSystem = "None"
 else:
 vcsSystem = "None"
 else:
 vcsSystem = vcsData[0][0]
-self.pdata["VCS"] = vcsSystem
+self.__pdata["VCS"] = vcsSystem
 self.vcs = self.initVCS()
 self.setDirty(True)
 if self.vcs is not None and (
 self.vcs.vcsRegisteredState(self.ppath)
 != self.vcs.canBeCommitted
 ):
-self.pdata["VCS"] = "None"
+self.__pdata["VCS"] = "None"
 self.vcs = self.initVCS()
 self.closeAct.setEnabled(True)
 self.saveasAct.setEnabled(True)
 self.actGrp2.setEnabled(True)
 self.propsAct.setEnabled(True)
 self.menuCheckAct.setEnabled(True)
 self.menuShowAct.setEnabled(True)
 self.menuDiagramAct.setEnabled(True)
 self.menuApidocAct.setEnabled(True)
 self.menuPackagersAct.setEnabled(True)
-self.pluginGrp.setEnabled(self.pdata["PROJECTTYPE"] in ["E7Plugin"])
+self.pluginGrp.setEnabled(
+self.__pdata["PROJECTTYPE"] in ["E7Plugin"]
+)
 self.addLanguageAct.setEnabled(
-bool(self.pdata["TRANSLATIONPATTERN"])
+bool(self.__pdata["TRANSLATIONPATTERN"])
 )
-self.makeGrp.setEnabled(self.pdata["MAKEPARAMS"]["MakeEnabled"])
+self.makeGrp.setEnabled(self.__pdata["MAKEPARAMS"]["MakeEnabled"])
-self.menuMakeAct.setEnabled(self.pdata["MAKEPARAMS"]["MakeEnabled"])
+self.menuMakeAct.setEnabled(
+self.__pdata["MAKEPARAMS"]["MakeEnabled"]
+)
 self.menuOtherToolsAct.setEnabled(True)
 self.menuFormattingAct.setEnabled(True)
 # open a project debugger properties file being quiet
 # about errors
 if Preferences.getProject("AutoLoadDbgProperties"):
 self.__readDebugProperties(True)
 self.__model.projectOpened()
-if self.pdata["EMBEDDED_VENV"]:
+if self.__pdata["EMBEDDED_VENV"]:
 envPath = self.__findEmbeddedEnvironment()
 if bool(envPath):
 self.__loadEnvironmentConfiguration()
 if not bool(
 self.__venvConfiguration["interpreter"]
 self.__venvConfiguration["interpreter"], os.X_OK
 ):
 self.__configureEnvironment(envPath)
 else:
 self.__createEmbeddedEnvironment()
-self.menuEnvironmentAct.setEnabled(self.pdata["EMBEDDED_VENV"])
+self.menuEnvironmentAct.setEnabled(self.__pdata["EMBEDDED_VENV"])
 self.projectOpenedHooks.emit()
 self.projectOpened.emit()
 if Preferences.getProject("SearchNewFiles"):
 if Preferences.getProject("TasksProjectRescanOnOpen"):
 ericApp().getObject("TaskViewer").regenerateProjectTasks(quiet=True)
 if restoreSession:
 # open the main script
-if self.pdata["MAINSCRIPT"]:
+if self.__pdata["MAINSCRIPT"]:
-if not os.path.isabs(self.pdata["MAINSCRIPT"]):
+if not os.path.isabs(self.__pdata["MAINSCRIPT"]):
-ms = os.path.join(self.ppath, self.pdata["MAINSCRIPT"])
+ms = os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 else:
-ms = self.pdata["MAINSCRIPT"]
+ms = self.__pdata["MAINSCRIPT"]
 self.sourceFile.emit(ms)
 # open a project session file being quiet about errors
 if reopen:
 self.__readSession(quiet=True, indicator="_tmp")
 vm = ericApp().getObject("ViewManager")
 success = True
 filesWithSyntaxErrors = 0
 for fn in vm.getOpenFilenames():
 rfn = self.getRelativePath(fn)
-if rfn in self.pdata["SOURCES"] or rfn in self.pdata["OTHERS"]:
+if rfn in self.__pdata["SOURCES"] or rfn in self.__pdata["OTHERS"]:
 editor = vm.getOpenEditor(fn)
 success &= vm.saveEditorEd(editor)
 if reportSyntaxErrors and editor.hasSyntaxErrors():
 filesWithSyntaxErrors += 1
 vm = ericApp().getObject("ViewManager")
 success = True
 filesWithSyntaxErrors = 0
 for fn in vm.getOpenFilenames():
 rfn = self.getRelativePath(fn)
-if rfn in self.pdata["SOURCES"] or rfn in self.pdata["OTHERS"]:
+if rfn in self.__pdata["SOURCES"] or rfn in self.__pdata["OTHERS"]:
 editor = vm.getOpenEditor(fn)
 success &= editor.checkDirty()
 if reportSyntaxErrors and editor.hasSyntaxErrors():
 filesWithSyntaxErrors += 1
 @param normalized flag indicating a normalized filename is wanted
 @type bool
 @return filename of the projects main script
 @rtype str
 """
-if self.pdata["MAINSCRIPT"]:
+if self.__pdata["MAINSCRIPT"]:
 if normalized:
-return os.path.join(self.ppath, self.pdata["MAINSCRIPT"])
+return os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 else:
-return self.pdata["MAINSCRIPT"]
+return self.__pdata["MAINSCRIPT"]
 else:
 return ""
 def getSources(self, normalized=False):
 """
 @type boolean
 @return list of file names
 @rtype list of str
 @exception ValueError raised when an unsupported file type is given
 """
-if fileType not in [
+if fileType not in self.__knownFileCategories:
-"SOURCES",
+##[
-"FORMS",
+##"SOURCES",
-"RESOURCES",
+##"FORMS",
-"INTERFACES",
+##"RESOURCES",
-"PROTOCOLS",
+##"INTERFACES",
-"OTHERS",
+##"PROTOCOLS",
-"TRANSLATIONS",
+##"OTHERS",
-]:
+##"TRANSLATIONS",
+##]:
 raise ValueError("Given file type has incorrect value.")
 if normalized:
-return [os.path.join(self.ppath, fn) for fn in self.pdata[fileType]]
+return [os.path.join(self.ppath, fn) for fn in self.__pdata[fileType]]
 else:
-return self.pdata[fileType]
+return self.__pdata[fileType]
 def getProjectType(self):
 """
 Public method to get the type of the project.
 @return UI type of the project (string)
 """
-return self.pdata["PROJECTTYPE"]
+return self.__pdata["PROJECTTYPE"]
 def getProjectLanguage(self):
 """
 Public method to get the project's programming language.
 @return programming language (string)
 """
-return self.pdata["PROGLANGUAGE"]
+return self.__pdata["PROGLANGUAGE"]
 def isMixedLanguageProject(self):
 """
 Public method to check, if this is a mixed language project.
 @return flag indicating a mixed language project
 @rtype bool
 """
-return self.pdata["MIXEDLANGUAGE"]
+return self.__pdata["MIXEDLANGUAGE"]
 def isPythonProject(self):
 """
 Public method to check, if this project is a Python3 or MicroPython
 project.
 @return flag indicating a Python project (boolean)
 """
-return self.pdata["PROGLANGUAGE"] in ["Python3", "MicroPython"]
+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 self.pdata["PROGLANGUAGE"] == "Python3"
+return self.__pdata["PROGLANGUAGE"] == "Python3"
 def isMicroPythonProject(self):
 """
 Public method to check, if this project is a MicroPython project.
 @return flag indicating a MicroPython project
 @rtype bool
 """
-return self.pdata["PROGLANGUAGE"] == "MicroPython"
+return self.__pdata["PROGLANGUAGE"] == "MicroPython"
 def isRubyProject(self):
 """
 Public method to check, if this project is a Ruby project.
 @return flag indicating a Ruby project (boolean)
 """
-return self.pdata["PROGLANGUAGE"] == "Ruby"
+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 self.pdata["PROGLANGUAGE"] == "JavaScript"
+return self.__pdata["PROGLANGUAGE"] == "JavaScript"
 def getProjectSpellLanguage(self):
 """
 Public method to get the project's programming language.
 @return programming language (string)
 """
-return self.pdata["SPELLLANGUAGE"]
+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
 project specific word and exclude list
 """
 pwl = ""
-if self.pdata["SPELLWORDS"]:
+if self.__pdata["SPELLWORDS"]:
-pwl = os.path.join(self.ppath, self.pdata["SPELLWORDS"])
+pwl = os.path.join(self.ppath, self.__pdata["SPELLWORDS"])
 if not os.path.isfile(pwl):
 pwl = ""
 pel = ""
-if self.pdata["SPELLEXCLUDES"]:
+if self.__pdata["SPELLEXCLUDES"]:
-pel = os.path.join(self.ppath, self.pdata["SPELLEXCLUDES"])
+pel = os.path.join(self.ppath, self.__pdata["SPELLEXCLUDES"])
 if not os.path.isfile(pel):
 pel = ""
 return (pwl, pel)
 Public method to get the default extension for the project's
 programming language.
 @return default extension (including the dot) (string)
 """
-lang = self.pdata["PROGLANGUAGE"]
+lang = self.__pdata["PROGLANGUAGE"]
 if lang in ("", "Python"):
 lang = "Python3"
 return self.__sourceExtensions(lang)[0]
 def getProjectPath(self):
 """
 Public method to get the project hash.
 @return project hash as a hex string (string)
 """
-return self.pdata["HASH"]
+return self.__pdata["HASH"]
 def getRelativePath(self, path):
 """
 Public method to convert a file path to a project relative
 file path.
 """
 Public method to get the EOL-string to be used by the project.
 @return eol string (string)
 """
-if self.pdata["EOL"] >= 0:
+if self.__pdata["EOL"] >= 0:
-return self.eols[self.pdata["EOL"]]
+return self.eols[self.__pdata["EOL"]]
 else:
 eolMode = Preferences.getEditor("EOLMode")
 if eolMode == QsciScintilla.EolMode.EolWindows:
 eol = "\r\n"
 elif eolMode == QsciScintilla.EolMode.EolUnix:
 """
 Public method to check, if the project uses the system eol setting.
 @return flag indicating the usage of system eol (boolean)
 """
-return self.pdata["EOL"] == 0
+return self.__pdata["EOL"] == 0
 def getProjectVersion(self):
 """
 Public mehod to get the version number of the project.
 @return version number
 @rtype str
 """
-return self.pdata["VERSION"]
+return self.__pdata["VERSION"]
 def getProjectAuthor(self):
 """
 Public method to get the author of the project.
 @return author name
 @rtype str
 """
-return self.pdata["AUTHOR"]
+return self.__pdata["AUTHOR"]
 def getProjectAuthorEmail(self):
 """
 Public method to get the email address of the project author.
 @return project author email
 @rtype str
 """
-return self.pdata["EMAIL"]
+return self.__pdata["EMAIL"]
 def getProjectDescription(self):
 """
 Public method to get the description of the project.
 @return project description
 @rtype str
 """
-return self.pdata["DESCRIPTION"]
+return self.__pdata["DESCRIPTION"]
 def getProjectVenv(self, resolveDebugger=True):
 """
 Public method to get the name of the virtual environment used by the
 project.
 @return name of the project's virtual environment
 @rtype str
 """
 venvName = (
 self.__venvConfiguration["name"]
-if self.pdata["EMBEDDED_VENV"] and bool(self.__venvConfiguration["name"])
+if self.__pdata["EMBEDDED_VENV"] and bool(self.__venvConfiguration["name"])
 else self.getDebugProperty("VIRTUALENV")
 )
 if (
 not venvName
 and resolveDebugger
 @return path of the project's interpreter
 @rtype str
 """
 interpreter = (
 self.__venvConfiguration["interpreter"]
-if self.pdata["EMBEDDED_VENV"]
+if self.__pdata["EMBEDDED_VENV"]
 else ""
 )
 if not interpreter:
 venvName = self.getProjectVenv()
 if venvName:
 Public method to get the executable search path prefix of the project.
 @return executable search path prefix
 @rtype str
 """
-if self.pdata["EMBEDDED_VENV"]:
+if self.__pdata["EMBEDDED_VENV"]:
 execPath = self.__venvConfiguration["exec_path"]
 else:
 execPath = ""
 venvName = self.getProjectVenv()
 if venvName:
 @return testing framework name of the project
 @rtype str
 """
 try:
-return self.pdata["TESTING_FRAMEWORK"]
+return self.__pdata["TESTING_FRAMEWORK"]
 except KeyError:
 return ""
 def getProjectLicense(self):
 """
 @return license type of the project
 @rtype str
 """
 try:
-return self.pdata["LICENSE"]
+return self.__pdata["LICENSE"]
 except KeyError:
 return ""
 def __isInPdata(self, fn):
 """
 @rtype bool
 """
 newfn = os.path.abspath(fn)
 newfn = self.getRelativePath(newfn)
 return any(
-newfn in self.pdata[group]
+newfn in self.__pdata[category]
-for group in [
+for category in self.__knownFileCategories
-"SOURCES",
+##[
-"FORMS",
+##"SOURCES",
-"INTERFACES",
+##"FORMS",
-"PROTOCOLS",
+##"INTERFACES",
-"RESOURCES",
+##"PROTOCOLS",
-"TRANSLATIONS",
+##"RESOURCES",
-"OTHERS",
+##"TRANSLATIONS",
-]
+##"OTHERS",
+##]
 )
 def isProjectFile(self, fn):
 """
 Public method used to check, if the passed in filename belongs to the
 @param fn filename to be checked (string)
 @return flag indicating membership (boolean)
 """
 return any(
-self.__checkProjectFileGroup(fn, group)
+self.__checkProjectFileGroup(fn, category)
-for group in [
+for category in self.__knownFileCategories
-"SOURCES",
+##[
-"FORMS",
+##"SOURCES",
-"INTERFACES",
+##"FORMS",
-"PROTOCOLS",
+##"INTERFACES",
-"RESOURCES",
+##"PROTOCOLS",
-"TRANSLATIONS",
+##"RESOURCES",
-"OTHERS",
+##"TRANSLATIONS",
-]
+##"OTHERS",
+##]
 )
 def __checkProjectFileGroup(self, fn, group):
 """
 Private method to check, if a file is in a specific file group of the
 @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] or (
+if newfn in self.__pdata[group] or (
 group == "OTHERS"
-and any(newfn.startswith(entry) for entry in self.pdata[group])
+and any(newfn.startswith(entry) for entry in self.__pdata[group])
 ):
 return True
 if Utilities.isWindowsPlatform():
 # try the above case-insensitive
 newfn = newfn.lower()
-if any(entry.lower() == newfn for entry in self.pdata[group]):
+if any(entry.lower() == newfn for entry in self.__pdata[group]):
 return True
 elif group == "OTHERS" and any(
-newfn.startswith(entry.lower()) for entry in self.pdata[group]
+newfn.startswith(entry.lower()) for entry in self.__pdata[group]
 ):
 return True
 return False
+# TODO: change the following methods to a more generic logix using fileCategories
 def isProjectSource(self, fn):
 """
 Public method used to check, if the passed in filename belongs to the
 project sources.
 def __showMenu(self):
 """
 Private method to set up the project menu.
 """
 self.menuRecentAct.setEnabled(len(self.recent) > 0)
-self.menuEnvironmentAct.setEnabled(self.pdata["EMBEDDED_VENV"])
+self.menuEnvironmentAct.setEnabled(self.__pdata["EMBEDDED_VENV"])
 self.showMenu.emit("Main", self.__menus["Main"])
 def __syncRecent(self):
 """
 recursiveSearch = Preferences.getProject("SearchNewFilesRecursively")
 newFiles = []
 ignore_patterns = [
 pattern
-for pattern, filetype in self.pdata["FILETYPES"].items()
+for pattern, filetype in self.__pdata["FILETYPES"].items()
 if filetype == "__IGNORE__"
 ]
 dirs = self.subdirs[:]
 for directory in dirs:
 try:
 newSources = os.listdir(curpath)
 except OSError:
 newSources = []
 pattern = (
-self.pdata["TRANSLATIONPATTERN"].replace("%language%", "*")
+self.__pdata["TRANSLATIONPATTERN"].replace("%language%", "*")
-if self.pdata["TRANSLATIONPATTERN"]
+if self.__pdata["TRANSLATIONPATTERN"]
 else "*.ts"
 )
 binpattern = self.__binaryTranslationFile(pattern)
 for ns in newSources:
 # ignore hidden files and directories
 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"].keys(), reverse=True):
 if fnmatch.fnmatch(bfn, pattern):
-filetype = self.pdata["FILETYPES"][pattern]
+filetype = self.__pdata["FILETYPES"][pattern]
 break
 if (
-(filetype == "SOURCES" and fn not in self.pdata["SOURCES"])
+filetype in self.__knownFileCategories
-or (filetype == "FORMS" and fn not in self.pdata["FORMS"])
+and fn not in self.__pdata[filetype]
-or (filetype == "INTERFACES" and fn not in self.pdata["INTERFACES"])
+and (
-or (filetype == "PROTOCOLS" and fn not in self.pdata["PROTOCOLS"])
+filetype != "TRANSLATIONS"
-or (filetype == "RESOURCES" and fn not in self.pdata["RESOURCES"])
+or (
-or (filetype == "OTHERS" and fn not in self.pdata["OTHERS"])
+filetype == "TRANSLATIONS"
-or (
+and (
-filetype == "TRANSLATIONS"
+fnmatch.fnmatch(ns, pattern)
-and fn not in self.pdata["TRANSLATIONS"]
+or fnmatch.fnmatch(ns, binpattern)
-and (
+)
-fnmatch.fnmatch(ns, pattern)
-or fnmatch.fnmatch(ns, binpattern)
 )
 )
 ):
+##(filetype == "SOURCES" and fn not in self.__pdata["SOURCES"])
+##or (filetype == "FORMS" and fn not in self.__pdata["FORMS"])
+##or (filetype == "INTERFACES" and fn not in self.__pdata["INTERFACES"])
+##or (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"])
+##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)
 vcs = None
 forProject = True
 override = False
 if vcsSystem is None:
-if self.pdata["VCS"] and self.pdata["VCS"] != "None":
+if self.__pdata["VCS"] and self.__pdata["VCS"] != "None":
-vcsSystem = self.pdata["VCS"]
+vcsSystem = self.__pdata["VCS"]
 else:
 forProject = False
 if (
 forProject
-and self.pdata["VCS"]
+and self.__pdata["VCS"]
-and self.pdata["VCS"] != "None"
+and self.__pdata["VCS"] != "None"
 and self.pudata["VCSOVERRIDE"]
 and not nooverride
 ):
 vcsSystem = self.pudata["VCSOVERRIDE"]
 override = True
 "<p>{1}</p>"
 ).format(vcsSystem, msg),
 )
 vcs = None
 if forProject:
-self.pdata["VCS"] = "None"
+self.__pdata["VCS"] = "None"
 self.setDirty(True)
 else:
 vcs.vcsInitConfig(self)
 if vcs and forProject:
 # set the vcs options
 if vcs.vcsSupportCommandOptions():
 with contextlib.suppress(LookupError):
-vcsopt = copy.deepcopy(self.pdata["VCSOPTIONS"])
+vcsopt = copy.deepcopy(self.__pdata["VCSOPTIONS"])
 vcs.vcsSetOptions(vcsopt)
 # set vcs specific data
 with contextlib.suppress(LookupError):
-vcsother = copy.deepcopy(self.pdata["VCSOTHERDATA"])
+vcsother = copy.deepcopy(self.__pdata["VCSOTHERDATA"])
 vcs.vcsSetOtherData(vcsother)
 if forProject:
 if vcs is None:
 self.vcsProjectHelper = VCS.getBasicHelper(self)
 def resetVCS(self):
 """
 Public method to reset the VCS.
 """
-self.pdata["VCS"] = "None"
+self.__pdata["VCS"] = "None"
 self.vcs = self.initVCS()
 ericApp().getObject("PluginManager").deactivateVcsPlugins()
 def __showContextMenuVCS(self):
 """
 """
 from eric7.DataViews.CodeMetricsDialog import CodeMetricsDialog
 files = [
 os.path.join(self.ppath, file)
-for file in self.pdata["SOURCES"]
+for file in self.__pdata["SOURCES"]
 if file.endswith(".py")
 ]
 self.codemetrics = CodeMetricsDialog()
 self.codemetrics.show()
 self.codemetrics.prepare(files)
 else:
 return
 files = [
 os.path.join(self.ppath, file)
-for file in self.pdata["SOURCES"]
+for file in self.__pdata["SOURCES"]
 if os.path.splitext(file)[1].startswith(".py")
 ]
 self.codecoverage = PyCoverageDialog()
 self.codecoverage.show()
 self.codecoverage.start(fn, files)
 if not res:
 return  # don't overwrite
 # build the list of entries
 lst_ = []
-for key in [
+for key in self.__knownFileCategories:
-"SOURCES",
+##[
-"FORMS",
+##"SOURCES",
-"RESOURCES",
+##"FORMS",
-"TRANSLATIONS",
+##"RESOURCES",
-"INTERFACES",
+##"TRANSLATIONS",
-"PROTOCOLS",
+##"INTERFACES",
-"OTHERS",
+##"PROTOCOLS",
-]:
+##"OTHERS",
-lst_.extend(self.pdata[key])
+##]:
+lst_.extend(self.__pdata[key])
 lst = []
 for entry in lst_:
 if os.path.isdir(self.getAbsolutePath(entry)):
 lst.extend(
 [
 " ",
 ]
 # write the file
 try:
-newline = None if self.pdata["EOL"] == 0 else self.getEolString()
+newline = None if self.__pdata["EOL"] == 0 else 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) for f in lst])
 )
 """<p>Reason: {0}</p>"""
 ).format(str(why)),
 )
 return
-if "PKGLIST" not in self.pdata["OTHERS"]:
+if "PKGLIST" not in self.__pdata["OTHERS"]:
 self.appendFile("PKGLIST")
 @pyqtSlot()
 def __pluginCreateArchives(self, snapshot=False):
 """
 Private slot to create eric plugin archives.
 @param snapshot flag indicating snapshot archives (boolean)
 """
-if not self.pdata["MAINSCRIPT"]:
+if not self.__pdata["MAINSCRIPT"]:
 EricMessageBox.critical(
 self.ui,
 self.tr("Create Plugin Archive"),
 self.tr(
 """The project does not have a main script defined. """
 names = sorted(names)
 archive = (
 os.path.join(self.ppath, archiveName)
 if archiveName
 else os.path.join(
-self.ppath, self.pdata["MAINSCRIPT"].replace(".py", ".zip")
+self.ppath, self.__pdata["MAINSCRIPT"].replace(".py", ".zip")
 )
 )
 try:
 archiveFile = zipfile.ZipFile(archive, "w")
 except OSError as why:
 for name in names:
 if name:
 try:
 self.__createZipDirEntries(os.path.split(name)[0], archiveFile)
-if snapshot and name == self.pdata["MAINSCRIPT"]:
+if snapshot and name == self.__pdata["MAINSCRIPT"]:
 snapshotSource, version = self.__createSnapshotSource(
-os.path.join(self.ppath, self.pdata["MAINSCRIPT"])
+os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 )
 archiveFile.writestr(name, snapshotSource)
 else:
 archiveFile.write(os.path.join(self.ppath, name), name)
-if name == self.pdata["MAINSCRIPT"]:
+if name == self.__pdata["MAINSCRIPT"]:
 version = self.__pluginExtractVersion(
-os.path.join(self.ppath, self.pdata["MAINSCRIPT"])
+os.path.join(self.ppath, self.__pdata["MAINSCRIPT"])
 )
 if archiveVersion and (
 self.__pluginVersionToTuple(version)
 < self.__pluginVersionToTuple(archiveVersion)
 ):
 ).format(os.path.join(self.ppath, name), str(why)),
 )
 archiveFile.writestr("VERSION", version.encode("utf-8"))
 archiveFile.close()
-if archive not in self.pdata["OTHERS"]:
+if archive not in self.__pdata["OTHERS"]:
 self.appendFile(archive)
 progress.setValue(len(selectedLists))
 if errors:
 parameters.
 @return flag indicating default parameter set
 @rtype bool
 """
-return self.pdata["MAKEPARAMS"] == {
+return self.__pdata["MAKEPARAMS"] == {
 "MakeEnabled": False,
 "MakeExecutable": "",
 "MakeFile": "",
 "MakeTarget": "",
 "MakeParameters": "",
 Public method to test, if make is enabled for the project.
 @return flag indicating enabled make support
 @rtype bool
 """
-return self.pdata["MAKEPARAMS"]["MakeEnabled"]
+return self.__pdata["MAKEPARAMS"]["MakeEnabled"]
 @pyqtSlot()
 def executeMake(self):
 """
 Public slot to execute a project specific make run (auto-run)
 (execute or question).
 """
 self.__executeMake(
-questionOnly=self.pdata["MAKEPARAMS"]["MakeTestOnly"], interactive=False
+questionOnly=self.__pdata["MAKEPARAMS"]["MakeTestOnly"], interactive=False
 )
 @pyqtSlot()
 def __executeMake(self, questionOnly=False, interactive=True):
 """
 @param interactive flag indicating an interactive invocation (i.e.
 through a menu action)
 @type bool
 """
 if (
-not self.pdata["MAKEPARAMS"]["MakeEnabled"]
+not self.__pdata["MAKEPARAMS"]["MakeEnabled"]
 or self.__makeProcess is not None
 ):
 return
 prog = (
-self.pdata["MAKEPARAMS"]["MakeExecutable"]
+self.__pdata["MAKEPARAMS"]["MakeExecutable"]
-if self.pdata["MAKEPARAMS"]["MakeExecutable"]
+if self.__pdata["MAKEPARAMS"]["MakeExecutable"]
 else Project.DefaultMake
 )
 args = []
-if self.pdata["MAKEPARAMS"]["MakeParameters"]:
+if self.__pdata["MAKEPARAMS"]["MakeParameters"]:
 args.extend(
-Utilities.parseOptionString(self.pdata["MAKEPARAMS"]["MakeParameters"])
+Utilities.parseOptionString(
-)
+self.__pdata["MAKEPARAMS"]["MakeParameters"]
+)
-if self.pdata["MAKEPARAMS"]["MakeFile"]:
+)
-args.append("--makefile={0}".format(self.pdata["MAKEPARAMS"]["MakeFile"]))
+if self.__pdata["MAKEPARAMS"]["MakeFile"]:
+args.append("--makefile={0}".format(self.__pdata["MAKEPARAMS"]["MakeFile"]))
 if questionOnly:
 args.append("--question")
-if self.pdata["MAKEPARAMS"]["MakeTarget"]:
+if self.__pdata["MAKEPARAMS"]["MakeTarget"]:
-args.append(self.pdata["MAKEPARAMS"]["MakeTarget"])
+args.append(self.__pdata["MAKEPARAMS"]["MakeTarget"])
 self.__makeProcess = QProcess(self)
 self.__makeProcess.readyReadStandardOutput.connect(self.__makeReadStdOut)
 self.__makeProcess.readyReadStandardError.connect(self.__makeReadStdErr)
 self.__makeProcess.finished.connect(
 else:
 if questionOnly and exitCode == 1:
 # a rebuild is needed
 title = self.tr("Test for Changes")
-if self.pdata["MAKEPARAMS"]["MakeTarget"]:
+if self.__pdata["MAKEPARAMS"]["MakeTarget"]:
 message = self.tr(
 """<p>There are changes that require the configured"""
 """ make target <b>{0}</b> to be rebuilt.</p>"""
-).format(self.pdata["MAKEPARAMS"]["MakeTarget"])
+).format(self.__pdata["MAKEPARAMS"]["MakeTarget"])
 else:
 message = self.tr(
 """<p>There are changes that require the default"""
 """ make target to be rebuilt.</p>"""
 )
 parameters.
 @return flag indicating default parameter set
 @rtype bool
 """
-return self.pdata["IDLPARAMS"] == {
+return self.__pdata["IDLPARAMS"] == {
 "IncludeDirs": [],
 "DefinedNames": [],
 "UndefinedNames": [],
 }
 parameters.
 @return flag indicating default parameter set
 @rtype bool
 """
-return self.pdata["UICPARAMS"] == {
+return self.__pdata["UICPARAMS"] == {
 "Package": "",
 "RcSuffix": "",
 "PackagesRoot": "",
 }
 @param name name of the parameter
 @type str
 @return value of the given parameter
 @rtype any, None in case on non-existence
 """
-if name in self.pdata["UICPARAMS"]:
+if name in self.__pdata["UICPARAMS"]:
-return self.pdata["UICPARAMS"][name]
+return self.__pdata["UICPARAMS"][name]
 else:
 return None
 #########################################################################
 ## Below are methods implementing some 'RCC' support functions
 parameters.
 @return flag indicating default parameter set
 @rtype bool
 """
-return self.pdata["RCCPARAMS"] == self.getDefaultRccCompilerParameters()
+return self.__pdata["RCCPARAMS"] == self.getDefaultRccCompilerParameters()
 def getDefaultRccCompilerParameters(self):
 """
 Public method to get the default rcc compiler parameters.
 parameter.
 @return flag indicating default parameter
 @rtype bool
 """
-return self.pdata["DOCSTRING"] == ""
+return self.__pdata["DOCSTRING"] == ""
 def getDocstringType(self):
 """
 Public method to get the configured docstring style.
 @return configured docstring style
 @rtype str
 """
-return self.pdata["DOCSTRING"]
+return self.__pdata["DOCSTRING"]
 #########################################################################
 ## Below are methods implementing the 'SBOM' support
 #########################################################################
 Private method to set the embedded environment project configuration.
 @param value flag indicating an embedded environment
 @type bool
 """
-if value != self.pdata["EMBEDDED_VENV"]:
+if value != self.__pdata["EMBEDDED_VENV"]:
-self.pdata["EMBEDDED_VENV"] = value
+self.__pdata["EMBEDDED_VENV"] = value
 self.setDirty(True)
 def __initVenvConfiguration(self):
 """
 Private method to initialize the environment configuration.

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py