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

-:24c847222774
+:67295777d9fe
 """
 Module implementing the project management functionality.
 """
+import collections
 import contextlib
 import copy
 import fnmatch
 import glob
 import json
 import pathlib
 import shutil
 import time
 import zipfile
+from PyQt6.Qsci import QsciScintilla
 from PyQt6.QtCore import (
-pyqtSlot,
+QByteArray,
+QCryptographicHash,
 QFile,
-pyqtSignal,
-QCryptographicHash,
 QIODevice,
-QByteArray,
 QObject,
 QProcess,
+pyqtSignal,
+pyqtSlot,
 )
-from PyQt6.QtGui import QKeySequence, QAction
+from PyQt6.QtGui import QAction, QKeySequence
-from PyQt6.QtWidgets import QLineEdit, QToolBar, QDialog, QInputDialog, QMenu
+from PyQt6.QtWidgets import QDialog, QInputDialog, QLineEdit, QMenu, QToolBar
-from PyQt6.Qsci import QsciScintilla
+from eric7 import Globals, Preferences, Utilities
+from eric7.CodeFormatting.BlackFormattingAction import BlackFormattingAction
+from eric7.CodeFormatting.BlackUtilities import aboutBlack
+from eric7.CodeFormatting.IsortFormattingAction import IsortFormattingAction
+from eric7.CodeFormatting.IsortUtilities import aboutIsort
+from eric7.EricGui import EricPixmapCache
+from eric7.EricGui.EricAction import EricAction, createActionGroup
+from eric7.EricGui.EricOverrideCursor import EricOverrideCursor, EricOverridenCursor
+from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
-from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricListSelectionDialog import EricListSelectionDialog
 from eric7.EricWidgets.EricProgressDialog import EricProgressDialog
-from eric7.EricGui.EricOverrideCursor import EricOverrideCursor, EricOverridenCursor
+from eric7.EricXML.DebuggerPropertiesReader import DebuggerPropertiesReader
+from eric7.EricXML.ProjectReader import ProjectReader
+from eric7.EricXML.SessionReader import SessionReader
+from eric7.EricXML.TasksReader import TasksReader
+from eric7.EricXML.UserProjectReader import UserProjectReader
 from eric7.Globals import recentNameProject
+from eric7.Sessions.SessionFile import SessionFile
-from eric7.EricGui import EricPixmapCache
+from eric7.Tasks.TasksFile import TasksFile
 from eric7.UI import Config
 from eric7.UI.NotificationWidget import NotificationTypes
-from eric7.EricGui.EricAction import EricAction, createActionGroup
+from .DebuggerPropertiesFile import DebuggerPropertiesFile
+from .FileCategoryRepositoryItem import FileCategoryRepositoryItem
-from eric7 import Globals, Preferences, Utilities
+from .ProjectBrowserModel import ProjectBrowserModel
 from .ProjectFile import ProjectFile
 from .UserProjectFile import UserProjectFile
-from .DebuggerPropertiesFile import DebuggerPropertiesFile
-from eric7.Sessions.SessionFile import SessionFile
-from eric7.Tasks.TasksFile import TasksFile
-from eric7.CodeFormatting.BlackFormattingAction import BlackFormattingAction
-from eric7.CodeFormatting.BlackUtilities import aboutBlack
 class Project(QObject):
 """
 Class implementing the project management functionality.
 @signal dirty(bool) emitted when the dirty state changes
-@signal projectLanguageAdded(str) emitted after a new language was added
+@signal projectFileAdded(str, str) emitted after a new file was added
+@signal projectFileRemoved(str, str) emitted after a file of the project was removed
+@signal projectFileCompiled(str, str) emitted after a form was compiled
 @signal projectLanguageAddedByCode(str) emitted after a new language was
 added. The language code is sent by this signal.
-@signal projectLanguageRemoved(str) emitted after a language was removed
-@signal projectFormAdded(str) emitted after a new form was added
-@signal projectFormRemoved(str) emitted after a form was removed
-@signal projectFormCompiled(str) emitted after a form was compiled
-@signal projectSourceAdded(str) emitted after a new source file was added
-@signal projectSourceRemoved(str) emitted after a source was removed
-@signal projectInterfaceAdded(str) emitted after a new IDL file was added
-@signal projectInterfaceRemoved(str) emitted after a IDL file was removed
-@signal projectProtocolAdded(str) emitted after a new proto file was added
-@signal projectProtocolRemoved(str) emitted after a proto file was removed
-@signal projectResourceAdded(str) emitted after a new resource file was
-added
-@signal projectResourceRemoved(str) emitted after a resource was removed
-@signal projectOthersAdded(str) emitted after a file or directory was added
-to the OTHERS project data area
-@signal projectOthersRemoved(str) emitted after a file was removed from the
-OTHERS project data area
 @signal projectAboutToBeCreated() emitted just before the project will be
 created
 @signal newProjectHooks() emitted after a new project was generated but
 before the newProject() signal is sent
 @signal newProject() emitted after a new project was generated
 @signal projectChanged() emitted to signal a change of the project
 @signal appendStdout(str) emitted after something was received from
 a QProcess on stdout
 @signal appendStderr(str) emitted after something was received from
 a QProcess on stderr
+@signal processChangedProjectFiles() emitted to indicate, that changed project files
+should be processed
 """
 dirty = pyqtSignal(bool)
-projectLanguageAdded = pyqtSignal(str)
+projectFileAdded = pyqtSignal(str, str)
+projectFileRemoved = pyqtSignal(str, str)
+projectFileCompiled = pyqtSignal(str, str)
 projectLanguageAddedByCode = pyqtSignal(str)
-projectLanguageRemoved = pyqtSignal(str)
-projectFormAdded = pyqtSignal(str)
-projectFormRemoved = pyqtSignal(str)
-projectFormCompiled = pyqtSignal(str)
-projectSourceAdded = pyqtSignal(str)
-projectSourceRemoved = pyqtSignal(str)
-projectInterfaceAdded = pyqtSignal(str)
-projectInterfaceRemoved = pyqtSignal(str)
-projectProtocolAdded = pyqtSignal(str)
-projectProtocolRemoved = pyqtSignal(str)
-projectResourceAdded = pyqtSignal(str)
-projectResourceRemoved = pyqtSignal(str)
-projectOthersAdded = pyqtSignal(str)
-projectOthersRemoved = pyqtSignal(str)
 projectAboutToBeCreated = pyqtSignal()
 newProjectHooks = pyqtSignal()
 newProject = pyqtSignal()
 sourceFile = pyqtSignal(str)
 designerFile = pyqtSignal(str)
 showMenu = pyqtSignal(str, QMenu)
 lexerAssociationsChanged = pyqtSignal()
 projectChanged = pyqtSignal()
 appendStdout = pyqtSignal(str)
 appendStderr = pyqtSignal(str)
+processChangedProjectFiles = pyqtSignal()
 eols = [os.linesep, "\n", "\r", "\r\n"]
 DefaultMake = "make"
 DefaultMakefile = "makefile"
 "Python3": self.tr(
 "Python3 Files (*.py *.py3);;" "Python3 GUI Files (*.pyw *.pyw3);;"
 ),
 }
+self.__fileCategoriesRepository = {}
+# This dictionary will be populated by the various project browsers with
+# classes of type 'FileCategoryRepositoryItem' using the 'addFileCategory()
+# and removeFileCategory() methods.
 self.vcsMenu = None
 self.__makeProcess = None
 self.__initProjectTypes()
 if filename is not None:
 self.openProject(filename)
 else:
 self.vcs = self.initVCS()
-from .ProjectBrowserModel import ProjectBrowserModel
 self.__model = ProjectBrowserModel(self)
 self.codemetrics = None
 self.codecoverage = None
 self.profiledata = None
 self.applicationDiagram = None
 self.loadedDiagram = None
 self.__findProjectFileDialog = None
+self.processChangedProjectFiles.connect(self.__autoExecuteMake)
+def addFileCategory(self, category, categoryItem):
+"""
+Public method to add a file category to the categories repository.
+Note: The given category must not be contained in the repository already.
+@param category file category (must be unique)
+@type str
+@param categoryItem data class instance containing the category data
+@type FileCategoryRepositoryItem
+@exception TypeError raised to signal a wrong type for the category item
+"""
+if not isinstance(categoryItem, FileCategoryRepositoryItem):
+raise TypeError(
+"'categoryItem' must be an instance of 'FileCategoryRepositoryItem'."
+)
+if category in self.__fileCategoriesRepository:
+EricMessageBox.critical(
+self.ui,
+self.tr("Add File Category"),
+self.tr(
+"<p>The file category <b>{0}</b> has already been added. This"
+" attempt will be ignored.</p>"
+),
+)
+else:
+self.__fileCategoriesRepository[category] = categoryItem
+with contextlib.suppress(AttributeError):
+self.__pdata[category] = []
+def removeFileCategory(self, category):
+"""
+Public method to remove a category from the categories repository.
+Note: If the category is not contained in the repository, the request to
+remove it will be ignored silently.
+@param category file category
+@type str
+"""
+with contextlib.suppress(KeyError):
+del self.__fileCategoriesRepository[category]
 def __sourceExtensions(self, language):
 """
 Private method to get the source extensions of a programming language.
 self.dbgGlobalConfigOverride = {
 "enable": False,
 "redirect": True,
 }
-self.pdata = {
+self.__pdata = {
 "DESCRIPTION": "",
 "VERSION": "",
-"SOURCES": [],
-"FORMS": [],
-"RESOURCES": [],
-"INTERFACES": [],
-"PROTOCOLS": [],
-"OTHERS": [],
-"TRANSLATIONS": [],
 "TRANSLATIONEXCEPTIONS": [],
 "TRANSLATIONPATTERN": "",
 "TRANSLATIONSBINPATH": "",
 "TRANSLATIONSOURCESTARTPATH": "",
 "MAINSCRIPT": "",
 "DOCSTRING": "",
 "TESTING_FRAMEWORK": "",
 "LICENSE": "",
 "EMBEDDED_VENV": False,
 }
+for category in self.__fileCategoriesRepository:
+self.__pdata[category] = []
 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, setDirty=True):
+"""
+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)
+@param setDirty flag indicating to set the dirty flag if the data is different
+from the current one (defaults to True)
+@type bool (optional)
+"""
+if dataKey is None:
+self.__pdata.update(data)
+else:
+if self.__pdata[dataKey] != data and setDirty:
+self.setDirty(True)
+self.__pdata[dataKey] = data
 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 list(self.__fileCategoriesRepository.keys())
+def getFileCategoryFilterString(
+self, categories=None, withOthers=False, withAll=True
+):
+"""
+Public method to get a file selection string for the given categories.
+@param categories list of file type categories (defaults to None).
+A value of None means all categories except 'OTHERS'.
+@type list of str (optional)
+@param withOthers flag indicating to include the 'OTHERS' category
+(defaults to False)
+@type bool (optional)
+@param withAll flag indicating to include a filter for 'All Files'
+(defaults to True)
+@type bool (optional)
+@return file selection filter string
+@rtype str
+"""
+if categories is None:
+categories = [c for c in self.__fileCategoriesRepository if c != "OTHERS"]
+if withOthers:
+categories.append("OTHERS")
+patterns = collections.defaultdict(list)
+for pattern, filetype in self.__pdata["FILETYPES"].items():
+if filetype in categories and filetype in self.__fileCategoriesRepository:
+patterns[filetype].append(pattern)
+filters = []
+for filetype in patterns:
+filters.append(
+self.__fileCategoriesRepository[
+filetype
+].fileCategoryFilterTemplate.format(
+" ".join(sorted(patterns[filetype]))
+)
+)
+filterString = ";;".join(sorted(filters))
+if withAll:
+filterString += ";;" + self.tr("All Files (*)")
+return filterString
+def getFileCategoryString(self, category):
+"""
+Public method to get a user string for the given category.
+@param category file type category
+@type str
+@return user string for the category
+@rtype str
+"""
+return self.__fileCategoriesRepository[category].fileCategoryUserString
+def getFileCategoryType(self, category):
+"""
+Public method to get a user type string for the given category.
+@param category file type category
+@type str
+@return user type string for the category
+@rtype str
+"""
+return self.__fileCategoriesRepository[category].fileCategoryTyeString
+def getFileCategoryExtension(self, category, reverse=False):
+"""
+Public method to get a list of default file extensions for the given category.
+@param category file type category
+@type str
+@param reverse flag indicating to get all other extensions except the one of
+the given category
+@type bool
+@return list of default file extensions for the category
+@rtype list of str
+"""
+if reverse:
+extensions = []
+for cat, item in self.__fileCategoriesRepository.items():
+if cat != category:
+extensions += item.fileCategoryExtensions[:]
+return extensions
+else:
+return self.__fileCategoriesRepository[category].fileCategoryExtensions[:]
 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.
 res = self.__projectFile.readFile(fn)
 else:
 # old XML based format
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
-from eric7.EricXML.ProjectReader import ProjectReader
 reader = ProjectReader(f, self)
 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.getFileCategories():
-self.__checkFilesExist("FORMS")
+self.__checkFilesExist(fileCategory)
-self.__checkFilesExist("INTERFACES")
-self.__checkFilesExist("PROTOCOLS")
-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 [c for c in self.getFileCategories() if c != "OTHERS"]:
-self.pdata["SOURCES"]
+for fn in self.__pdata[fileCategory]:
-+ self.pdata["FORMS"]
+dn = os.path.dirname(fn)
-+ self.pdata["INTERFACES"]
+if dn not in self.subdirs:
-+ self.pdata["PROTOCOLS"]
+self.subdirs.append(dn)
-+ self.pdata["RESOURCES"]
-+ self.pdata["TRANSLATIONS"]
-):
-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():
 # try the old XML based format second
 fn = os.path.join(self.getProjectManagementDir(), "{0}.e4q".format(fn1))
 if os.path.exists(fn):
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
-from eric7.EricXML.UserProjectReader import UserProjectReader
 reader = UserProjectReader(f, self)
 reader.readXML()
 f.close()
 else:
 EricMessageBox.critical(
 self.getProjectManagementDir(), "{0}{1}.e5s".format(fn1, indicator)
 )
 if os.path.exists(fn):
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
-from eric7.EricXML.SessionReader import SessionReader
 reader = SessionReader(f, False)
 reader.readXML(quiet=quiet)
 f.close()
 else:
 if not quiet:
 # try old style XML file second
 fn = os.path.join(self.getProjectManagementDir(), "{0}.e6t".format(base))
 if os.path.exists(fn):
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
-from eric7.EricXML.TasksReader import TasksReader
 reader = TasksReader(f, True)
 reader.readXML()
 f.close()
 else:
 EricMessageBox.critical(
 # try the old XML based format second
 fn = os.path.join(self.getProjectManagementDir(), "{0}.e4d".format(fn1))
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
-from eric7.EricXML.DebuggerPropertiesReader import (
-DebuggerPropertiesReader,
-)
 reader = DebuggerPropertiesReader(f, self)
 reader.readXML(quiet=quiet)
 f.close()
 self.debugPropertiesLoaded = True
 self.debugPropertiesChanged = False
 """
 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.
 """
-if not self.pdata["TRANSLATIONPATTERN"]:
+from .AddLanguageDialog import AddLanguageDialog
+if not self.__pdata["TRANSLATIONPATTERN"]:
 EricMessageBox.critical(
 self.ui,
 self.tr("Add Language"),
 self.tr("You have to specify a translation pattern first."),
 )
 return
-from .AddLanguageDialog import AddLanguageDialog
 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):
 """
 Public slot to delete a translation from the project directory.
 @param langFile the translation file to be removed (string)
 """
 try:
-from send2trash import send2trash as s2t
+from send2trash import send2trash as s2t  # __IGNORE_WARNING_I10__
 except ImportError:
 s2t = os.remove
 langFile = self.getRelativePath(langFile)
 qmFile = self.__binaryTranslationFile(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
-if filetype in ["SOURCES", "FORMS", "INTERFACES", "PROTOCOLS", "RESOURCES"]:
+if filetype in (
-if filetype == "SOURCES":
+category
-if newfn not in self.pdata["SOURCES"]:
+for category in self.getFileCategories()
-self.pdata["SOURCES"].append(newfn)
+if category not in ("TRANSLATIONS", "OTHERS")
-self.projectSourceAdded.emit(newfn)
+):
-updateModel and self.__model.addNewItem("SOURCES", newfn)
+if newfn not in self.__pdata[filetype]:
-dirty = True
+self.__pdata[filetype].append(newfn)
-else:
+self.projectFileAdded.emit(newfn, filetype)
-updateModel and self.repopulateItem(newfn)
+updateModel and self.__model.addNewItem(filetype, newfn)
-elif filetype == "FORMS":
+dirty = True
-if newfn not in self.pdata["FORMS"]:
+else:
-self.pdata["FORMS"].append(newfn)
+updateModel and self.repopulateItem(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"]:
-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"]:
-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"]:
-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)
+self.projectFileAdded.emit(newfn, "TRANSLATIONS")
 dirty = True
 else:
 updateModel and self.repopulateItem(newfn)
-else:  # filetype == "OTHERS"
+elif 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 fileTypeFilter filter to be used by the add file dialog
 @type str out of source, form, resource, interface, protocol, others
 @param startdir start directory for the selection dialog
 @type str
 """
+from .AddFileDialog import AddFileDialog
 if startdir is None:
 startdir = self.ppath
-from .AddFileDialog import AddFileDialog
 dlg = AddFileDialog(self, self.parent(), fileTypeFilter, startdir=startdir)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 fnames, target, isSource = dlg.getData()
 if target != "":
 @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):
 @param fileTypeFilter filter to be used by the add directory dialog
 @type str out of source, form, resource, interface, protocol, others
 @param startdir start directory for the selection dialog
 @type str
 """
+from .AddDirectoryDialog import AddDirectoryDialog
 if startdir is None:
 startdir = self.ppath
-from .AddDirectoryDialog import AddDirectoryDialog
 dlg = AddDirectoryDialog(self, fileTypeFilter, self.parent(), startdir=startdir)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 filetype, source, target, recursive = dlg.getData()
 if target == "":
 # 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)
-def addSourceFiles(self):
-"""
-Public slot to add source files to the current project.
-"""
-self.addFiles("source")
-def addUiFiles(self):
-"""
-Public slot to add forms to the current project.
-"""
-self.addFiles("form")
-def addIdlFiles(self):
-"""
-Public slot to add IDL interfaces to the current project.
-"""
-self.addFiles("interface")
-def addProtoFiles(self):
-"""
-Public slot to add protocol files to the current project.
-"""
-self.addFiles("protocol")
-def addResourceFiles(self):
-"""
-Public slot to add Qt resources to the current project.
-"""
-self.addFiles("resource")
-def addOthersFiles(self):
-"""
-Public slot to add files to the OTHERS project data.
-"""
-self.addFiles("others")
-def addSourceDir(self):
-"""
-Public slot to add all source files of a directory to the current
-project.
-"""
-self.addDirectory("source")
-def addUiDir(self):
-"""
-Public slot to add all forms of a directory to the current project.
-"""
-self.addDirectory("form")
-def addIdlDir(self):
-"""
-Public slot to add all IDL interfaces of a directory to the current
-project.
-"""
-self.addDirectory("interface")
-def addProtoDir(self):
-"""
-Public slot to add all protocol files of a directory to the current
-project.
-"""
-self.addDirectory("protocol")
-def addResourceDir(self):
-"""
-Public slot to add all Qt resource files of a directory to the current
-project.
-"""
-self.addDirectory("resource")
-def addOthersDir(self):
-"""
-Public slot to add a directory to the OTHERS project data.
-"""
-self.addDirectory("others")
 def renameMainScript(self, oldfn, newfn):
 """
 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 any(fn in self.__pdata[category] for category in self.getFileCategories()):
-fn in self.pdata["SOURCES"]
-or fn in self.pdata["FORMS"]
-or fn in self.pdata["TRANSLATIONS"]
-or fn in self.pdata["INTERFACES"]
-or fn in self.pdata["PROTOCOLS"]
-or fn in self.pdata["RESOURCES"]
-or fn in self.pdata["OTHERS"]
-):
 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 fileCategory in [
-"SOURCES",
+c for c in self.getFileCategories() if c != "TRANSLATIONS"
-"FORMS",
-"INTERFACES",
-"PROTOCOLS",
-"RESOURCES",
-"OTHERS",
 ]:
-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 fileCategory in self.getFileCategories():
-"SOURCES",
+newPdata[fileCategory] = []
-"FORMS",
-"INTERFACES",
-"PROTOCOLS",
-"RESOURCES",
-"OTHERS",
-"TRANSLATIONS",
-]:
-newPdata[key] = []
 # iterate over all files checking for a reassignment
-for key in [
+for fileCategory in self.getFileCategories():
-"SOURCES",
+for fn in self.__pdata[fileCategory][:]:
-"FORMS",
+filetype = fileCategory
-"INTERFACES",
-"PROTOCOLS",
-"RESOURCES",
-"OTHERS",
-"TRANSLATIONS",
-]:
-for fn in self.pdata[key][:]:
-filetype = key
 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.getFileCategories():
+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.getFileCategories() 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.getFileCategories() 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 fn filename to be removed from the project
 @param updateModel flag indicating an update of the model is
 requested (boolean)
 """
 fn = self.getRelativePath(fn)
-dirty = True
+for fileCategory in self.getFileCategories():
-if fn in self.pdata["SOURCES"]:
+if fn in self.__pdata[fileCategory]:
-self.pdata["SOURCES"].remove(fn)
+self.__pdata[fileCategory].remove(fn)
-self.projectSourceRemoved.emit(fn)
+self.projectFileRemoved.emit(fn, fileCategory)
-elif fn in self.pdata["FORMS"]:
+self.setDirty(True)
-self.pdata["FORMS"].remove(fn)
+if updateModel:
-self.projectFormRemoved.emit(fn)
+self.__model.removeItem(fn)
-elif fn in self.pdata["INTERFACES"]:
+break
-self.pdata["INTERFACES"].remove(fn)
-self.projectInterfaceRemoved.emit(fn)
-elif fn in self.pdata["PROTOCOLS"]:
-self.pdata["PROTOCOLS"].remove(fn)
-self.projectProtocolRemoved.emit(fn)
-elif fn in self.pdata["RESOURCES"]:
-self.pdata["RESOURCES"].remove(fn)
-self.projectResourceRemoved.emit(fn)
-elif fn in self.pdata["OTHERS"]:
-self.pdata["OTHERS"].remove(fn)
-self.projectOthersRemoved.emit(fn)
-elif fn in self.pdata["TRANSLATIONS"]:
-self.pdata["TRANSLATIONS"].remove(fn)
-self.projectLanguageRemoved.emit(fn)
-else:
-dirty = False
-updateModel and self.__model.removeItem(fn)
-if dirty:
-self.setDirty(True)
 def removeDirectory(self, dn):
 """
 Public method to remove a directory from the project.
 @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 fileCategory in [c for c in self.getFileCategories() if c != "OTHERS"]:
-"SOURCES",
+for entry in self.__pdata[fileCategory][:]:
-"FORMS",
-"INTERFACES",
-"PROTOCOLS",
-"RESOURCES",
-"TRANSLATIONS",
-]:
-for entry in self.pdata[key][:]:
 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 deleted from the project
 @return flag indicating success (boolean)
 """
 try:
-from send2trash import send2trash as s2t
+from send2trash import send2trash as s2t  # __IGNORE_WARNING_I10__
 except ImportError:
 s2t = os.remove
 try:
 s2t(os.path.join(self.ppath, fn))
 """
 if not os.path.isabs(dn):
 dn = os.path.join(self.ppath, dn)
 try:
 try:
-from send2trash import send2trash
+from send2trash import send2trash  # __IGNORE_WARNING_I10__
 send2trash(dn)
 except ImportError:
 shutil.rmtree(dn, True)
 except OSError as err:
 @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.getFileCategories()
-or fn in self.pdata["INTERFACES"]
+if category != "TRANSLATIONS"
-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.
 This method displays the new project dialog and initializes
 the project object with the data entered.
 """
+from eric7.VCS.CommandOptionsDialog import VcsCommandOptionsDialog
+from .PropertiesDialog import PropertiesDialog
 if not self.checkDirty():
 return
-from .PropertiesDialog import PropertiesDialog
 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.reloadAct.setEnabled(True)
 self.closeAct.setEnabled(True)
 self.saveasAct.setEnabled(True)
 self.actGrp2.setEnabled(True)
 self.propsAct.setEnabled(True)
 self.userPropsAct.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():
 ),
 )
 else:
 vcores = False
 if vcores:
-from eric7.VCS.CommandOptionsDialog import (
-VcsCommandOptionsDialog,
-)
 codlg = VcsCommandOptionsDialog(self.vcs)
 if codlg.exec() == QDialog.DialogCode.Accepted:
 self.vcs.vcsSetOptions(codlg.getOptions())
 # add project file to repository
 if res == 0:
 )
 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:
 vcores = False
 if vcores:
-from eric7.VCS.CommandOptionsDialog import (
-VcsCommandOptionsDialog,
-)
 codlg = VcsCommandOptionsDialog(self.vcs)
 if codlg.exec() == QDialog.DialogCode.Accepted:
 self.vcs.vcsSetOptions(codlg.getOptions())
 # create the project in the VCS
 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)
+self.projectFileAdded.emit(ts, "TRANSLATIONS")
-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)
+self.projectFileAdded.emit(qm, "TRANSLATIONS")
-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.
 """
-vcsSystem = self.pdata["VCS"] or None
+from .UserPropertiesDialog import UserPropertiesDialog
+vcsSystem = self.__pdata["VCS"] or None
 vcsSystemOverride = self.pudata["VCSOVERRIDE"] or None
-from .UserPropertiesDialog import UserPropertiesDialog
 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"])
 def getFiletypeAssociations(self, associationType):
 """
 Public method to get the list of file type associations for
 the given association type.
-@param associationType type of the association (one of FORMS,
+@param associationType type of the association (one of the known file categories
-INTERFACES, OTHERS, PROTOCOLS, RESOURCES, SOURCES,
+or __IGNORE__)
-TRANSLATIONS or __IGNORE__)
 @type str
 @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.reloadAct.setEnabled(True)
 self.closeAct.setEnabled(True)
 self.saveasAct.setEnabled(True)
 self.actGrp2.setEnabled(True)
 self.propsAct.setEnabled(True)
 self.userPropsAct.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")
 # now close all project related tool windows
 self.__closeAllWindows()
 self.__initData()
+self.reloadAct.setEnabled(False)
 self.closeAct.setEnabled(False)
 self.saveasAct.setEnabled(False)
 self.saveAct.setEnabled(False)
 self.actGrp2.setEnabled(False)
 self.propsAct.setEnabled(False)
 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):
 """
 def getProjectFiles(self, fileType, normalized=False):
 """
 Public method to get the file entries of the given type.
-@param fileType project file type (one of SOURCES, FORMS, RESOURCES,
+@param fileType project file type (one of the known file categories)
-INTERFACES, PROTOCOLS, OTHERS, TRANSLATIONS)
 @type str
 @param normalized flag indicating normalized file names are wanted
 @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.getFileCategories():
-"SOURCES",
-"FORMS",
-"RESOURCES",
-"INTERFACES",
-"PROTOCOLS",
-"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 category in self.getFileCategories()
-for group in [
-"SOURCES",
-"FORMS",
-"INTERFACES",
-"PROTOCOLS",
-"RESOURCES",
-"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.getFileCategories()
-"SOURCES",
-"FORMS",
-"INTERFACES",
-"PROTOCOLS",
-"RESOURCES",
-"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]
+elif group == "OTHERS" and any(
-):
+newfn.startswith(entry.lower()) for entry in self.__pdata[group]
-return True
+):
+return True
 return False
-def isProjectSource(self, fn):
+def isProjectCategory(self, fn, category):
 """
-Public method used to check, if the passed in filename belongs to the
+Public method to check, if the passed in filename belongs to the given
-project sources.
+category.
-@param fn filename to be checked (string)
-@return flag indicating membership (boolean)
-"""
-return self.__checkProjectFileGroup(fn, "SOURCES")
-def isProjectForm(self, fn):
-"""
-Public method used to check, if the passed in filename belongs to the
-project forms.
-@param fn filename to be checked (string)
-@return flag indicating membership (boolean)
-"""
-return self.__checkProjectFileGroup(fn, "FORMS")
-def isProjectInterface(self, fn):
-"""
-Public method used to check, if the passed in filename belongs to the
-project interfaces.
-@param fn filename to be checked (string)
-@return flag indicating membership (boolean)
-"""
-return self.__checkProjectFileGroup(fn, "INTERFACES")
-def isProjectProtocol(self, fn):
-"""
-Public method used to check, if the passed in filename belongs to the
-project protocols.
 @param fn filename to be checked
+@type str
+@param category file category to check against
 @type str
 @return flag indicating membership
 @rtype bool
 """
-return self.__checkProjectFileGroup(fn, "PROTOCOLS")
+if category in self.getFileCategories():
+return self.__checkProjectFileGroup(fn, category)
-def isProjectResource(self, fn):
+else:
-"""
+return False  # unknown category always returns False
-Public method used to check, if the passed in filename belongs to the
-project resources.
-@param fn filename to be checked (string)
-@return flag indicating membership (boolean)
-"""
-return self.__checkProjectFileGroup(fn, "RESOURCES")
 def initActions(self):
 """
 Public slot to initialize the project related actions.
 """
 self.actGrp1,
 "project_open",
 )
 act.setStatusTip(self.tr("Open an existing project"))
 act.setWhatsThis(
-self.tr("""<b>Open...</b>""" """<p>This opens an existing project.</p>""")
+self.tr("""<b>Open...</b><p>This opens an existing project.</p>""")
 )
 act.triggered.connect(self.openProject)
 self.actions.append(act)
+self.reloadAct = EricAction(
+self.tr("Reload project"),
+EricPixmapCache.getIcon("projectReload"),
+self.tr("&Reload"),
+0,
+0,
+self.actGrp1,
+"project_reload",
+)
+self.reloadAct.setStatusTip(self.tr("Reload the current project"))
+self.reloadAct.setWhatsThis(
+self.tr("""<b>Reload</b><p>This reloads the current project.</p>""")
+)
+self.reloadAct.triggered.connect(self.reopenProject)
+self.actions.append(self.reloadAct)
 self.closeAct = EricAction(
 self.tr("Close project"),
 EricPixmapCache.getIcon("projectClose"),
 self.tr("&Close"),
 self,
 "project_close",
 )
 self.closeAct.setStatusTip(self.tr("Close the current project"))
 self.closeAct.setWhatsThis(
-self.tr("""<b>Close</b>""" """<p>This closes the current project.</p>""")
+self.tr("""<b>Close</b><p>This closes the current project.</p>""")
 )
 self.closeAct.triggered.connect(self.closeProject)
 self.actions.append(self.closeAct)
 self.saveAct = EricAction(
 self,
 "project_save",
 )
 self.saveAct.setStatusTip(self.tr("Save the current project"))
 self.saveAct.setWhatsThis(
-self.tr("""<b>Save</b>""" """<p>This saves the current project.</p>""")
+self.tr("""<b>Save</b><p>This saves the current project.</p>""")
 )
 self.saveAct.triggered.connect(self.saveProject)
 self.actions.append(self.saveAct)
 self.saveasAct = EricAction(
 )
 self.createSBOMAct.triggered.connect(self.__createSBOMFile)
 self.actions.append(self.createSBOMAct)
 ###################################################################
-## Project Tools - code formatting actions
+## Project Tools - code formatting actions - Black
 ###################################################################
 self.blackFormattingGrp = createActionGroup(self)
 self.blackAboutAct = EricAction(
 " project sources with 'Black'.</p>"
 )
 )
 self.blackConfigureAct.triggered.connect(self.__configureBlack)
 self.actions.append(self.blackConfigureAct)
+###################################################################
+## Project Tools - code formatting actions - isort
+###################################################################
+self.isortFormattingGrp = createActionGroup(self)
+self.isortAboutAct = EricAction(
+self.tr("About isort"),
+self.tr("&isort"),
+0,
+0,
+self.isortFormattingGrp,
+"project_isort_about",
+)
+self.isortAboutAct.setStatusTip(self.tr("Show some information about 'isort'."))
+self.isortAboutAct.setWhatsThis(
+self.tr(
+"<b>isort</b>"
+"<p>This shows some information about the installed 'isort' tool.</p>"
+)
+)
+self.isortAboutAct.triggered.connect(aboutIsort)
+self.actions.append(self.isortAboutAct)
+font = self.isortAboutAct.font()
+font.setBold(True)
+self.isortAboutAct.setFont(font)
+self.isortSortImportsAct = EricAction(
+self.tr("Sort Imports"),
+self.tr("Sort Imports"),
+0,
+0,
+self.isortFormattingGrp,
+"project_isort_sort_imports",
+)
+self.isortSortImportsAct.setStatusTip(
+self.tr("Sort the import statements of the project sources with 'isort'.")
+)
+self.isortSortImportsAct.setWhatsThis(
+self.tr(
+"<b>Sort Imports</b>"
+"<p>This shows a dialog to enter parameters for the imports sorting"
+" run and sorts the import statements of the project sources using"
+" 'isort'.</p>"
+)
+)
+self.isortSortImportsAct.triggered.connect(
+lambda: self.__performImportSortingWithIsort(IsortFormattingAction.Sort)
+)
+self.actions.append(self.isortSortImportsAct)
+self.isortDiffSortingAct = EricAction(
+self.tr("Imports Sorting Diff"),
+self.tr("Imports Sorting Diff"),
+0,
+0,
+self.isortFormattingGrp,
+"project_isort_diff_code",
+)
+self.isortDiffSortingAct.setStatusTip(
+self.tr(
+"Generate a unified diff of potential project source imports"
+" resorting with 'isort'."
+)
+)
+self.isortDiffSortingAct.setWhatsThis(
+self.tr(
+"<b>Imports Sorting Diff</b>"
+"<p>This shows a dialog to enter parameters for the imports sorting"
+" diff run and generates a unified diff of potential project source"
+" changes using 'isort'.</p>"
+)
+)
+self.isortDiffSortingAct.triggered.connect(
+lambda: self.__performImportSortingWithIsort(IsortFormattingAction.Diff)
+)
+self.actions.append(self.isortDiffSortingAct)
+self.isortConfigureAct = EricAction(
+self.tr("Configure"),
+self.tr("Configure"),
+0,
+0,
+self.isortFormattingGrp,
+"project_isort_configure",
+)
+self.isortConfigureAct.setStatusTip(
+self.tr(
+"Enter the parameters for resorting the project sources import"
+" statements with 'isort'."
+)
+)
+self.isortConfigureAct.setWhatsThis(
+self.tr(
+"<b>Configure</b>"
+"<p>This shows a dialog to enter the parameters for resorting the"
+" import statements of the project sources with 'isort'.</p>"
+)
+)
+self.isortConfigureAct.triggered.connect(self.__configureIsort)
+self.actions.append(self.isortConfigureAct)
 ###################################################################
 ## Project - embedded environment actions
 ###################################################################
 )
 )
 self.recreateVenvAct.triggered.connect(self.__createEmbeddedEnvironment)
 self.actions.append(self.recreateVenvAct)
+self.reloadAct.setEnabled(False)
 self.closeAct.setEnabled(False)
 self.saveAct.setEnabled(False)
 self.saveasAct.setEnabled(False)
 self.actGrp2.setEnabled(False)
 self.propsAct.setEnabled(False)
 self.othersMenu.addSeparator()
 # build the 'Code Formatting' menu
 self.formattingMenu.setTearOffEnabled(True)
 self.formattingMenu.addActions(self.blackFormattingGrp.actions())
+self.formattingMenu.addSeparator()
+self.formattingMenu.addActions(self.isortFormattingGrp.actions())
 self.formattingMenu.addSeparator()
 # build the project main menu
 menu.setTearOffEnabled(True)
 menu.addActions(self.actGrp1.actions())
 @param toolbarManager reference to a toolbar manager object
 (EricToolBarManager)
 @return tuple of the generated toolbars (tuple of two QToolBar)
 """
+from eric7 import VCS
 tb = QToolBar(self.tr("Project"), self.ui)
 tb.setIconSize(Config.ToolBarIconSize)
 tb.setObjectName("ProjectToolbar")
 tb.setToolTip(self.tr("Project"))
 toolbarManager.addAction(self.addDirectoryAct, tb.windowTitle())
 toolbarManager.addAction(self.addLanguageAct, tb.windowTitle())
 toolbarManager.addAction(self.propsAct, tb.windowTitle())
 toolbarManager.addAction(self.userPropsAct, tb.windowTitle())
-from eric7 import VCS
 vcstb = VCS.getBasicHelper(self).initBasicToolbar(self.ui, toolbarManager)
 return tb, vcstb
 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):
 """
 def __searchProjectFile(self):
 """
 Private slot to show the Find Project File dialog.
 """
+from .QuickFindFileDialog import QuickFindFileDialog
 if self.__findProjectFileDialog is None:
-from .QuickFindFileDialog import QuickFindFileDialog
 self.__findProjectFileDialog = QuickFindFileDialog(self)
 self.__findProjectFileDialog.sourceFile.connect(self.sourceFile)
 self.__findProjectFileDialog.designerFile.connect(self.designerFile)
 self.__findProjectFileDialog.linguistFile.connect(self.linguistFile)
 self.__findProjectFileDialog.show()
 @param AI flag indicating whether the automatic inclusion should
 be honoured (boolean)
 @param onUserDemand flag indicating whether this method was
 requested by the user via a menu action (boolean)
 """
+from .AddFoundFilesDialog import AddFoundFilesDialog
 autoInclude = Preferences.getProject("AutoIncludeNewFiles")
 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.getFileCategories()
-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)
 )
 )
 ):
 if autoInclude and AI:
 self.appendFile(ns)
 self.tr("There were no new files found to be added."),
 )
 return
 # autoInclude is not set, show a dialog
-from .AddFoundFilesDialog import AddFoundFilesDialog
 dlg = AddFoundFilesDialog(newFiles, self.parent(), None)
 res = dlg.exec()
 # the 'Add All' button was pressed
 if res == 1:
 @param fn filename or directory name added (string)
 @param updateModel flag indicating an update of the model is requested
 (boolean)
 """
-self.projectOthersAdded.emit(fn)
+self.projectFileAdded.emit(fn, "OTHERS")
 updateModel and self.__model.addNewItem("OTHERS", fn)
 def getActions(self):
 """
 Public method to get a list of all actions.
 @param vcsSystem type of VCS to be used (string)
 @param nooverride flag indicating to ignore an override request
 (boolean)
 @return a reference to the vcs object
 """
+from eric7 import VCS
 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
 if vcsSystem is not None:
-from eric7 import VCS
 try:
 vcs = VCS.factory(vcsSystem)
 except ImportError:
 if override:
 # override failed, revert to original
 "<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:
-from eric7 import VCS
 self.vcsProjectHelper = VCS.getBasicHelper(self)
 self.vcsBasicHelper = True
 else:
 self.vcsProjectHelper = vcs.vcsGetProjectHelper(self)
 self.vcsBasicHelper = False
 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):
 """
 def __showCodeMetrics(self):
 """
 Private slot used to calculate some code metrics for the project files.
 """
+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")
 ]
-from eric7.DataViews.CodeMetricsDialog import CodeMetricsDialog
 self.codemetrics = CodeMetricsDialog()
 self.codemetrics.show()
 self.codemetrics.prepare(files)
 def __showCodeCoverage(self):
 """
 Private slot used to show the code coverage information for the
 project files.
 """
+from eric7.DataViews.PyCoverageDialog import PyCoverageDialog
 fn = self.getMainScript(True)
 if fn is None:
 EricMessageBox.critical(
 self.ui,
 self.tr("Coverage Data"),
 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")
 ]
-from eric7.DataViews.PyCoverageDialog import PyCoverageDialog
 self.codecoverage = PyCoverageDialog()
 self.codecoverage.show()
 self.codecoverage.start(fn, files)
 def __showProfileData(self):
 """
 Private slot used to show the profiling information for the project.
 """
+from eric7.DataViews.PyProfileDialog import PyProfileDialog
 fn = self.getMainScript(True)
 if fn is None:
 EricMessageBox.critical(
 self.ui,
 self.tr("Profile Data"),
 else:
 fn = files[0]
 else:
 return
-from eric7.DataViews.PyProfileDialog import PyProfileDialog
 self.profiledata = PyProfileDialog()
 self.profiledata.show()
 self.profiledata.start(fn)
 def __showContextMenuShow(self):
 def handleApplicationDiagram(self):
 """
 Public method to handle the application diagram context menu action.
 """
+from eric7.Graphics.UMLDialog import UMLDialog, UMLDialogType
 res = EricMessageBox.yesNo(
 self.ui,
 self.tr("Application Diagram"),
 self.tr("""Include module names?"""),
 yesDefault=True,
 )
-from eric7.Graphics.UMLDialog import UMLDialog, UMLDialogType
 self.applicationDiagram = UMLDialog(
 UMLDialogType.APPLICATION_DIAGRAM, self, self.parent(), noModules=not res
 )
 self.applicationDiagram.show()
 if not res:
 return  # don't overwrite
 # build the list of entries
 lst_ = []
-for key in [
+for key in self.getFileCategories():
-"SOURCES",
+lst_.extend(self.__pdata[key])
-"FORMS",
-"RESOURCES",
-"TRANSLATIONS",
-"INTERFACES",
-"PROTOCOLS",
-"OTHERS",
-]:
-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):
+def __autoExecuteMake(self):
 """
-Public slot to execute a project specific make run (auto-run)
+Private slot to execute a project specific make run (auto-run)
 (execute or question).
 """
-self.__executeMake(
+if Preferences.getProject("AutoExecuteMake"):
-questionOnly=self.pdata["MAKEPARAMS"]["MakeTestOnly"], interactive=False
+self.__executeMake(
-)
+questionOnly=self.__pdata["MAKEPARAMS"]["MakeTestOnly"],
+interactive=False,
+)
 @pyqtSlot()
 def __executeMake(self, questionOnly=False, interactive=True):
 """
 Private method to execute a project specific make run.
 @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
 #########################################################################
 @pyqtSlot()
 def __createSBOMFile(self):
 """
 Private slot to create a SBOM file of the project dependencies.
 """
-import CycloneDXInterface
+import CycloneDXInterface  # __IGNORE_WARNING_I102__
 CycloneDXInterface.createCycloneDXFile("<project>")
 #########################################################################
 ## Below are methods implementing the 'Code Formatting' support
 dlg = BlackConfigurationDialog(withProject=True, onlyProject=True)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 dlg.getConfiguration(saveToProject=True)
 # The data is saved to the project as a side effect.
+def __performImportSortingWithIsort(self, action):
+"""
+Private method to format the project sources import statements using the
+'isort' tool.
+Following actions are supported.
+<ul>
+<li>IsortFormattingAction.Format - the imports reformatting is performed</li>
+<li>IsortFormattingAction.Check - a check is performed, if imports formatting
+is necessary</li>
+<li>IsortFormattingAction.Diff - a unified diff of potential imports formatting
+changes is generated</li>
+</ul>
+@param action formatting operation to be performed
+@type IsortFormattingAction
+"""
+from eric7.CodeFormatting.IsortConfigurationDialog import (
+IsortConfigurationDialog,
+)
+from eric7.CodeFormatting.IsortFormattingDialog import IsortFormattingDialog
+if ericApp().getObject("ViewManager").checkAllDirty():
+dlg = IsortConfigurationDialog(withProject=True)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+config = dlg.getConfiguration(saveToProject=True)
+isortDialog = IsortFormattingDialog(
+config,
+self.getProjectFiles("SOURCES", normalized=True),
+project=self,
+action=action,
+)
+isortDialog.exec()
+@pyqtSlot()
+def __configureIsort(self):
+"""
+Private slot to enter the parameters for formatting the import statements of the
+project sources with 'isort'.
+"""
+from eric7.CodeFormatting.IsortConfigurationDialog import (
+IsortConfigurationDialog,
+)
+dlg = IsortConfigurationDialog(withProject=True, onlyProject=True)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+dlg.getConfiguration(saveToProject=True)
+# The data is saved to the project as a side effect.
 #########################################################################
 ## Below are methods implementing the 'Embedded Environment' support
 #########################################################################
 def __showContextMenuEnvironment(self):
 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.
 @param upgrade flag indicating an upgrade operation (defaults to False)
 @type bool (optional)
 """
 from eric7.VirtualEnv.VirtualenvExecDialog import VirtualenvExecDialog
 from .ProjectVenvCreationParametersDialog import (
 ProjectVenvCreationParametersDialog,
 )
 dlg = ProjectVenvCreationParametersDialog(

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py