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

-:45e7bb09c120
+:80c06d472826
 )
 from PyQt6.QtGui import QKeySequence, QAction
 from PyQt6.QtWidgets import QLineEdit, QToolBar, QDialog, QInputDialog, QMenu
 from PyQt6.Qsci import QsciScintilla
-from EricWidgets.EricApplication import ericApp
+from eric7.EricWidgets.EricApplication import ericApp
-from EricWidgets import EricFileDialog, EricMessageBox
+from eric7.EricWidgets import EricFileDialog, EricMessageBox
-from EricWidgets.EricListSelectionDialog import EricListSelectionDialog
+from eric7.EricWidgets.EricListSelectionDialog import EricListSelectionDialog
-from EricWidgets.EricProgressDialog import EricProgressDialog
+from eric7.EricWidgets.EricProgressDialog import EricProgressDialog
-from EricGui.EricOverrideCursor import EricOverrideCursor, EricOverridenCursor
+from eric7.EricGui.EricOverrideCursor import EricOverrideCursor, EricOverridenCursor
-from Globals import recentNameProject
+from eric7.Globals import recentNameProject
-import UI.PixmapCache
+from eric7.EricGui import EricPixmapCache
-from UI.NotificationWidget import NotificationTypes
+from eric7.UI import Config
+from eric7.UI.NotificationWidget import NotificationTypes
-from EricGui.EricAction import EricAction, createActionGroup
+from eric7.EricGui.EricAction import EricAction, createActionGroup
-import Globals
-import Preferences
+from eric7 import Globals, Preferences, Utilities
-import Utilities
 from .ProjectFile import ProjectFile
 from .UserProjectFile import UserProjectFile
 from .DebuggerPropertiesFile import DebuggerPropertiesFile
-from Sessions.SessionFile import SessionFile
+from eric7.Sessions.SessionFile import SessionFile
-from Tasks.TasksFile import TasksFile
+from eric7.Tasks.TasksFile import TasksFile
-from CodeFormatting.BlackFormattingAction import BlackFormattingAction
+from eric7.CodeFormatting.BlackFormattingAction import BlackFormattingAction
 class Project(QObject):
 """
 Class implementing the project management functionality.
 res = self.__projectFile.readFile(fn)
 else:
 # old XML based format
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
-from EricXML.ProjectReader import ProjectReader
+from eric7.EricXML.ProjectReader import ProjectReader
 reader = ProjectReader(f, self)
 reader.readXML()
 res = not reader.hasError()
 f.close()
 # 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 EricXML.UserProjectReader import UserProjectReader
+from eric7.EricXML.UserProjectReader import UserProjectReader
 reader = UserProjectReader(f, self)
 reader.readXML()
 f.close()
 else:
 self.getProjectManagementDir(), "{0}{1}.e5s".format(fn1, indicator)
 )
 if os.path.exists(fn):
 f = QFile(fn)
 if f.open(QIODevice.OpenModeFlag.ReadOnly):
-from EricXML.SessionReader import SessionReader
+from eric7.EricXML.SessionReader import SessionReader
 reader = SessionReader(f, False)
 reader.readXML(quiet=quiet)
 f.close()
 else:
 # 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 EricXML.TasksReader import TasksReader
+from eric7.EricXML.TasksReader import TasksReader
 reader = TasksReader(f, True)
 reader.readXML()
 f.close()
 else:
 # 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 EricXML.DebuggerPropertiesReader import DebuggerPropertiesReader
+from eric7.EricXML.DebuggerPropertiesReader import (
+DebuggerPropertiesReader,
+)
 reader = DebuggerPropertiesReader(f, self)
 reader.readXML(quiet=quiet)
 f.close()
 self.debugPropertiesLoaded = True
 ),
 )
 else:
 vcores = False
 if vcores:
-from VCS.CommandOptionsDialog import (
+from eric7.VCS.CommandOptionsDialog import (
 VcsCommandOptionsDialog,
 )
 codlg = VcsCommandOptionsDialog(self.vcs)
 if codlg.exec() == QDialog.DialogCode.Accepted:
 ),
 )
 else:
 vcores = False
 if vcores:
-from VCS.CommandOptionsDialog import VcsCommandOptionsDialog
+from eric7.VCS.CommandOptionsDialog import (
+VcsCommandOptionsDialog,
+)
 codlg = VcsCommandOptionsDialog(self.vcs)
 if codlg.exec() == QDialog.DialogCode.Accepted:
 self.vcs.vcsSetOptions(codlg.getOptions())
 self.actGrp1 = createActionGroup(self)
 act = EricAction(
 self.tr("New project"),
-UI.PixmapCache.getIcon("projectNew"),
+EricPixmapCache.getIcon("projectNew"),
 self.tr("&New..."),
 0,
 0,
 self.actGrp1,
 "project_new",
 act.triggered.connect(self.createNewProject)
 self.actions.append(act)
 act = EricAction(
 self.tr("Open project"),
-UI.PixmapCache.getIcon("projectOpen"),
+EricPixmapCache.getIcon("projectOpen"),
 self.tr("&Open..."),
 0,
 0,
 self.actGrp1,
 "project_open",
 act.triggered.connect(self.openProject)
 self.actions.append(act)
 self.closeAct = EricAction(
 self.tr("Close project"),
-UI.PixmapCache.getIcon("projectClose"),
+EricPixmapCache.getIcon("projectClose"),
 self.tr("&Close"),
 0,
 0,
 self,
 "project_close",
 self.closeAct.triggered.connect(self.closeProject)
 self.actions.append(self.closeAct)
 self.saveAct = EricAction(
 self.tr("Save project"),
-UI.PixmapCache.getIcon("projectSave"),
+EricPixmapCache.getIcon("projectSave"),
 self.tr("&Save"),
 0,
 0,
 self,
 "project_save",
 self.saveAct.triggered.connect(self.saveProject)
 self.actions.append(self.saveAct)
 self.saveasAct = EricAction(
 self.tr("Save project as"),
-UI.PixmapCache.getIcon("projectSaveAs"),
+EricPixmapCache.getIcon("projectSaveAs"),
 self.tr("Save &as..."),
 0,
 0,
 self,
 "project_save_as",
 self.actGrp2 = createActionGroup(self)
 self.addFilesAct = EricAction(
 self.tr("Add files to project"),
-UI.PixmapCache.getIcon("fileMisc"),
+EricPixmapCache.getIcon("fileMisc"),
 self.tr("Add &files..."),
 0,
 0,
 self.actGrp2,
 "project_add_file",
 self.addFilesAct.triggered.connect(self.addFiles)
 self.actions.append(self.addFilesAct)
 self.addDirectoryAct = EricAction(
 self.tr("Add directory to project"),
-UI.PixmapCache.getIcon("dirOpen"),
+EricPixmapCache.getIcon("dirOpen"),
 self.tr("Add directory..."),
 0,
 0,
 self.actGrp2,
 "project_add_directory",
 self.addDirectoryAct.triggered.connect(self.addDirectory)
 self.actions.append(self.addDirectoryAct)
 self.addLanguageAct = EricAction(
 self.tr("Add translation to project"),
-UI.PixmapCache.getIcon("linguist4"),
+EricPixmapCache.getIcon("linguist4"),
 self.tr("Add &translation..."),
 0,
 0,
 self.actGrp2,
 "project_add_translation",
 act.triggered.connect(self.__searchProjectFile)
 self.actions.append(act)
 self.propsAct = EricAction(
 self.tr("Project properties"),
-UI.PixmapCache.getIcon("projectProps"),
+EricPixmapCache.getIcon("projectProps"),
 self.tr("&Properties..."),
 0,
 0,
 self,
 "project_properties",
 self.propsAct.triggered.connect(self.__showProperties)
 self.actions.append(self.propsAct)
 self.userPropsAct = EricAction(
 self.tr("User project properties"),
-UI.PixmapCache.getIcon("projectUserProps"),
+EricPixmapCache.getIcon("projectUserProps"),
 self.tr("&User Properties..."),
 0,
 0,
 self,
 "project_user_properties",
 self.pluginGrp = createActionGroup(self)
 self.pluginPkgListAct = EricAction(
 self.tr("Create Package List"),
-UI.PixmapCache.getIcon("pluginArchiveList"),
+EricPixmapCache.getIcon("pluginArchiveList"),
 self.tr("Create &Package List"),
 0,
 0,
 self.pluginGrp,
 "project_plugin_pkglist",
 self.pluginPkgListAct.triggered.connect(self.__pluginCreatePkgList)
 self.actions.append(self.pluginPkgListAct)
 self.pluginArchiveAct = EricAction(
 self.tr("Create Plugin Archives"),
-UI.PixmapCache.getIcon("pluginArchive"),
+EricPixmapCache.getIcon("pluginArchive"),
 self.tr("Create Plugin &Archives"),
 0,
 0,
 self.pluginGrp,
 "project_plugin_archive",
 self.pluginArchiveAct.triggered.connect(self.__pluginCreateArchives)
 self.actions.append(self.pluginArchiveAct)
 self.pluginSArchiveAct = EricAction(
 self.tr("Create Plugin Archives (Snapshot)"),
-UI.PixmapCache.getIcon("pluginArchiveSnapshot"),
+EricPixmapCache.getIcon("pluginArchiveSnapshot"),
 self.tr("Create Plugin Archives (&Snapshot)"),
 0,
 0,
 self.pluginGrp,
 "project_plugin_sarchive",
 @param toolbarManager reference to a toolbar manager object
 (EricToolBarManager)
 @return tuple of the generated toolbars (tuple of two QToolBar)
 """
 tb = QToolBar(self.tr("Project"), self.ui)
-tb.setIconSize(UI.Config.ToolBarIconSize)
+tb.setIconSize(Config.ToolBarIconSize)
 tb.setObjectName("ProjectToolbar")
 tb.setToolTip(self.tr("Project"))
 tb.addActions(self.actGrp1.actions())
 tb.addAction(self.closeAct)
 toolbarManager.addAction(self.addDirectoryAct, tb.windowTitle())
 toolbarManager.addAction(self.addLanguageAct, tb.windowTitle())
 toolbarManager.addAction(self.propsAct, tb.windowTitle())
 toolbarManager.addAction(self.userPropsAct, tb.windowTitle())
-import VCS
+from eric7 import VCS
 vcstb = VCS.getBasicHelper(self).initBasicToolbar(self.ui, toolbarManager)
 return tb, vcstb
 ):
 vcsSystem = self.pudata["VCSOVERRIDE"]
 override = True
 if vcsSystem is not None:
-import VCS
+from eric7 import VCS
 try:
 vcs = VCS.factory(vcsSystem)
 except ImportError:
 if override:
 vcsother = copy.deepcopy(self.pdata["VCSOTHERDATA"])
 vcs.vcsSetOtherData(vcsother)
 if forProject:
 if vcs is None:
-import VCS
+from eric7 import VCS
 self.vcsProjectHelper = VCS.getBasicHelper(self)
 self.vcsBasicHelper = True
 else:
 self.vcsProjectHelper = vcs.vcsGetProjectHelper(self)
 files = [
 os.path.join(self.ppath, file)
 for file in self.pdata["SOURCES"]
 if file.endswith(".py")
 ]
-from DataViews.CodeMetricsDialog import CodeMetricsDialog
+from eric7.DataViews.CodeMetricsDialog import CodeMetricsDialog
 self.codemetrics = CodeMetricsDialog()
 self.codemetrics.show()
 self.codemetrics.prepare(files)
 files = [
 os.path.join(self.ppath, file)
 for file in self.pdata["SOURCES"]
 if os.path.splitext(file)[1].startswith(".py")
 ]
-from DataViews.PyCoverageDialog import PyCoverageDialog
+from eric7.DataViews.PyCoverageDialog import PyCoverageDialog
 self.codecoverage = PyCoverageDialog()
 self.codecoverage.show()
 self.codecoverage.start(fn, files)
 else:
 fn = files[0]
 else:
 return
-from DataViews.PyProfileDialog import PyProfileDialog
+from eric7.DataViews.PyProfileDialog import PyProfileDialog
 self.profiledata = PyProfileDialog()
 self.profiledata.show()
 self.profiledata.start(fn)
 self.tr("Application Diagram"),
 self.tr("""Include module names?"""),
 yesDefault=True,
 )
-from Graphics.UMLDialog import UMLDialog, UMLDialogType
+from eric7.Graphics.UMLDialog import UMLDialog, UMLDialogType
 self.applicationDiagram = UMLDialog(
 UMLDialogType.APPLICATION_DIAGRAM, self, self.parent(), noModules=not res
 )
 self.applicationDiagram.show()
 def __loadDiagram(self):
 """
 Private slot to load a diagram from file.
 """
-from Graphics.UMLDialog import UMLDialog, UMLDialogType
+from eric7.Graphics.UMLDialog import UMLDialog, UMLDialogType
 self.loadedDiagram = None
 loadedDiagram = UMLDialog(UMLDialogType.NO_DIAGRAM, self, parent=self.parent())
 if loadedDiagram.load():
 self.loadedDiagram = loadedDiagram
 progress.setValue(len(selectedLists))
 if errors:
 self.ui.showNotification(
-UI.PixmapCache.getPixmap("pluginArchive48"),
+EricPixmapCache.getPixmap("pluginArchive48"),
 self.tr("Create Plugin Archive"),
 self.tr(
 "<p>The eric plugin archive files were "
 "created with some errors.</p>"
 ),
 kind=NotificationTypes.CRITICAL,
 timeout=0,
 )
 else:
 self.ui.showNotification(
-UI.PixmapCache.getPixmap("pluginArchive48"),
+EricPixmapCache.getPixmap("pluginArchive48"),
 self.tr("Create Plugin Archive"),
 self.tr(
 "<p>The eric plugin archive files were " "created successfully.</p>"
 ),
 )
 """<p>There are changes that require the default"""
 """ make target to be rebuilt.</p>"""
 )
 self.ui.showNotification(
-UI.PixmapCache.getPixmap("makefile48"),
+EricPixmapCache.getPixmap("makefile48"),
 title,
 message,
 kind=NotificationTypes.WARNING,
 timeout=0,
 )
 </ul>
 @param action formatting operation to be performed
 @type BlackFormattingAction
 """
-from CodeFormatting.BlackConfigurationDialog import BlackConfigurationDialog
+from eric7.CodeFormatting.BlackConfigurationDialog import (
-from CodeFormatting.BlackFormattingDialog import BlackFormattingDialog
+BlackConfigurationDialog,
+)
+from eric7.CodeFormatting.BlackFormattingDialog import BlackFormattingDialog
 if ericApp().getObject("ViewManager").checkAllDirty():
 dlg = BlackConfigurationDialog(withProject=True)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 config = dlg.getConfiguration(saveToProject=True)
 def __configureBlack(self):
 """
 Private slot to enter the parameters for formatting the project sources with
 'Black'.
 """
-from CodeFormatting.BlackConfigurationDialog import BlackConfigurationDialog
+from eric7.CodeFormatting.BlackConfigurationDialog import (
+BlackConfigurationDialog,
+)
 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.
 Private method to create the embedded virtual environment.
 @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(
 "createLog": True,
 "createScript": True,
 "logicalName": self.__venvConfiguration["name"],
 "pythonExe": pythonPath,
 }
-from VirtualEnv.VirtualenvExecDialog import VirtualenvExecDialog
 args = []
 if upgrade:
 args.append("--upgrade")
 else:

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py