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

-:0b936ff1bbb9
+:a2bc06a54d9d
 from eric7.EricGui.EricOverrideCursor import EricOverrideCursor, EricOverridenCursor
 from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.EricWidgets.EricListSelectionDialog import EricListSelectionDialog
 from eric7.EricWidgets.EricProgressDialog import EricProgressDialog
+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.Tasks.TasksFile import TasksFile
 from eric7.UI import Config
 from eric7.UI.NotificationWidget import NotificationTypes
 from .DebuggerPropertiesFile import DebuggerPropertiesFile
+from .ProjectBrowserModel import ProjectBrowserModel
 from .ProjectFile import ProjectFile
 from .UserProjectFile import UserProjectFile
 class Project(QObject):
 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
 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()
 # 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
 def addLanguage(self):
 """
 Public slot used to add a language to the project.
 """
+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 [
 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)
 @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 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 == "":
 @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:
 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()
 ),
 )
 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:
 ),
 )
 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
 def __showUserProperties(self):
 """
 Private slot to display the user specific properties dialog.
 """
+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()
 @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.addFilesAct, tb.windowTitle())
 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 __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 = [
 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 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:
 ):
 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
 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 __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"]
 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"),
 files = [
 os.path.join(self.ppath, file)
 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()
 @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

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py