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

-:90dc02c8a384
+:1da8bc75946f
 """
 Module implementing the project management functionality.
 """
+import contextlib
+import copy
+import fnmatch
+import glob
+import json
 import os
+import pathlib
+import shutil
 import time
-import shutil
-import glob
-import fnmatch
-import copy
 import zipfile
-import contextlib
-import pathlib
 from PyQt6.QtCore import (
 pyqtSlot,
 QFile,
 pyqtSignal,
 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 EricWidgets import EricFileDialog, EricMessageBox
+from EricWidgets import EricFileDialog, EricMessageBox, EricPathPickerDialog
 from EricWidgets.EricListSelectionDialog import EricListSelectionDialog
 from EricWidgets.EricProgressDialog import EricProgressDialog
 from EricGui.EricOverrideCursor import EricOverrideCursor, EricOverridenCursor
 from Globals import recentNameProject
 },
 "EOL": -1,
 "DOCSTRING": "",
 "TESTING_FRAMEWORK": "",
 "LICENSE": "",
+"EMBEDDED_VENV": False,
 }
 self.__initDebugProperties()
 self.pudata = {
 "VCSOVERRIDE": "",
 "VCSSTATUSMONITORINTERVAL": 0,
 }
 self.vcs = self.initVCS()
+self.__initVenvConfiguration()
 def getData(self, category, key):
 """
 Public method to get data out of the project data store.
 self.__dirty = dirty
 self.saveAct.setEnabled(dirty)
 self.dirty.emit(dirty)
 if self.__dirty:
 self.projectChanged.emit()
+# autosave functionality
+if dirty and Preferences.getProject("AutoSaveProject"):
+self.saveProject()
 def isDirty(self):
 """
 Public method to return the dirty state.
 self.newProject.emit()
 else:
 self.newProjectHooks.emit()
 self.newProject.emit()
+if self.pdata["EMBEDDED_VENV"]:
+self.__createEmbeddedEnvironment()
+self.menuEnvironmentAct.setEnabled(self.pdata["EMBEDDED_VENV"])
 def newProjectAddFiles(self, mainscript):
 """
 Public method to add files to a new project.
 self.projectPropertiesChanged.emit()
 if self.pdata["PROJECTTYPE"] != projectType:
 self.__reorganizeFiles()
+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
 # about errors
 if Preferences.getProject("AutoLoadDbgProperties"):
 self.__readDebugProperties(True)
 self.__model.projectOpened()
-self.projectOpenedHooks.emit()
-self.projectOpened.emit()
+if self.pdata["EMBEDDED_VENV"]:
+envPath = self.__findEmbeddedEnvironment()
+if bool(envPath):
+self.__loadEnvironmentConfiguration()
+if not bool(
+self.__venvConfiguration["interpreter"]
+) or not os.access(
+self.__venvConfiguration["interpreter"], os.X_OK
+):
+self.__configureEnvironment(envPath)
+else:
+self.__createEmbeddedEnvironment()
+self.menuEnvironmentAct.setEnabled(self.pdata["EMBEDDED_VENV"])
+self.projectOpenedHooks.emit()
+self.projectOpened.emit()
 if Preferences.getProject("SearchNewFiles"):
 self.__doSearchNewFiles()
 # read a project tasks file
 self.pluginGrp.setEnabled(False)
 self.makeGrp.setEnabled(False)
 self.menuMakeAct.setEnabled(False)
 self.menuOtherToolsAct.setEnabled(False)
 self.menuFormattingAct.setEnabled(False)
+self.menuEnvironmentAct.setEnabled(False)
 self.__model.projectClosed()
 self.projectClosedHooks.emit()
 self.projectClosed.emit(shutdown)
 environment name via the debugger settings if none was configured
 @type bool
 @return name of the project's virtual environment
 @rtype str
 """
-venvName = self.getDebugProperty("VIRTUALENV")
+venvName = (
+self.__venvConfiguration["name"]
+if self.pdata["EMBEDDED_VENV"] and bool(self.__venvConfiguration["name"])
+else self.getDebugProperty("VIRTUALENV")
+)
 if (
 not venvName
 and resolveDebugger
 and self.getProjectLanguage() in ("Python3", "MicroPython", "Cython")
 ):
 environment was configured
 @type bool
 @return path of the project's interpreter
 @rtype str
 """
-interpreter = ""
+interpreter = (
-venvName = self.getProjectVenv()
+self.__venvConfiguration["interpreter"]
-if venvName:
+if self.pdata["EMBEDDED_VENV"]
-interpreter = (
+else ""
-ericApp()
+)
-.getObject("VirtualEnvManager")
+if not interpreter:
-.getVirtualenvInterpreter(venvName)
+venvName = self.getProjectVenv()
-)
+if venvName:
+interpreter = (
+ericApp()
+.getObject("VirtualEnvManager")
+.getVirtualenvInterpreter(venvName)
+)
 if not interpreter and resolveGlobal:
 interpreter = Globals.getPythonExecutable()
 return interpreter
 Public method to get the executable search path prefix of the project.
 @return executable search path prefix
 @rtype str
 """
-execPath = ""
+if self.pdata["EMBEDDED_VENV"]:
-venvName = self.getProjectVenv()
+execPath = self.__venvConfiguration["exec_path"]
-if venvName:
+else:
-execPath = (
+execPath = ""
-ericApp().getObject("VirtualEnvManager").getVirtualenvExecPath(venvName)
+venvName = self.getProjectVenv()
-)
+if venvName:
+execPath = (
+ericApp()
+.getObject("VirtualEnvManager")
+.getVirtualenvExecPath(venvName)
+)
 return execPath
 def getProjectTestingFramework(self):
 """
 self.blackDiffFormattingAct.triggered.connect(
 lambda: self.__performFormatWithBlack(BlackFormattingAction.Diff)
 )
 self.actions.append(self.blackDiffFormattingAct)
+self.blackConfigureAct = EricAction(
+self.tr("Configure"),
+self.tr("Configure"),
+0,
+0,
+self.blackFormattingGrp,
+"project_black_configure",
+)
+self.blackConfigureAct.setStatusTip(
+self.tr(
+"Enter the parameters for formatting the project sources with 'Black'."
+)
+)
+self.blackConfigureAct.setWhatsThis(
+self.tr(
+"<b>Configure</b>"
+"<p>This shows a dialog to enter the parameters for formatting the"
+" project sources with 'Black'.</p>"
+)
+)
+self.blackConfigureAct.triggered.connect(self.__configureBlack)
+self.actions.append(self.blackConfigureAct)
+###################################################################
+## Project - embedded environment actions
+###################################################################
+self.embeddedEnvironmentGrp = createActionGroup(self)
+self.installVenvAct = EricAction(
+self.tr("Install Project"),
+self.tr("&Install Project"),
+0,
+0,
+self.embeddedEnvironmentGrp,
+"project_venv_install",
+)
+self.installVenvAct.setStatusTip(
+self.tr("Install the project into the embedded environment.")
+)
+self.installVenvAct.setWhatsThis(
+self.tr(
+"<b>Install Project</b>"
+"<p>This installs the project into the embedded virtual environment"
+" in editable mode (i.e. development mode).</p>"
+)
+)
+self.installVenvAct.triggered.connect(self.__installProjectIntoEnvironment)
+self.actions.append(self.installVenvAct)
+self.configureVenvAct = EricAction(
+self.tr("Configure"),
+self.tr("&Configure"),
+0,
+0,
+self.embeddedEnvironmentGrp,
+"project_venv_configure",
+)
+self.configureVenvAct.setStatusTip(
+self.tr("Configure the embedded environment.")
+)
+self.configureVenvAct.setWhatsThis(
+self.tr(
+"<b>Configure</b>"
+"<p>This opens a dialog to configure the embedded virtual environment"
+" of the project.</p>"
+)
+)
+self.configureVenvAct.triggered.connect(self.__configureEnvironment)
+self.actions.append(self.configureVenvAct)
 self.closeAct.setEnabled(False)
 self.saveAct.setEnabled(False)
 self.saveasAct.setEnabled(False)
 self.actGrp2.setEnabled(False)
 self.propsAct.setEnabled(False)
 """
 menu = QMenu(self.tr("&Project"), self.parent())
 self.recentMenu = QMenu(self.tr("Open &Recent Projects"), menu)
 self.sessionMenu = QMenu(self.tr("Session"), menu)
 self.debuggerMenu = QMenu(self.tr("Debugger"), menu)
+self.environmentMenu = QMenu(self.tr("Embedded Environment"), menu)
 toolsMenu = QMenu(self.tr("Project-T&ools"), self.parent())
 self.vcsMenu = QMenu(self.tr("&Version Control"), toolsMenu)
 self.vcsMenu.setTearOffEnabled(True)
 self.vcsProjectHelper.initMenu(self.vcsMenu)
 "Debugger": self.debuggerMenu,
 "Packagers": self.packagersMenu,
 "Make": self.makeMenu,
 "OtherTools": self.othersMenu,
 "Formatting": self.formattingMenu,
+"Environment": self.environmentMenu,
 }
 # connect the aboutToShow signals
 self.recentMenu.aboutToShow.connect(self.__showContextMenuRecent)
 self.recentMenu.triggered.connect(self.__openRecent)
 self.sessionMenu.aboutToShow.connect(self.__showContextMenuSession)
 self.debuggerMenu.aboutToShow.connect(self.__showContextMenuDebugger)
 self.makeMenu.aboutToShow.connect(self.__showContextMenuMake)
 self.othersMenu.aboutToShow.connect(self.__showContextMenuOthers)
 self.formattingMenu.aboutToShow.connect(self.__showContextMenuFormat)
+self.environmentMenu.aboutToShow.connect(self.__showContextMenuEnvironment)
 menu.aboutToShow.connect(self.__showMenu)
 # build the show menu
 self.menuShow.setTearOffEnabled(True)
 self.menuShow.addAction(self.codeMetricsAct)
 self.sessionMenu.addActions(self.sessActGrp.actions())
 # build the debugger menu
 self.debuggerMenu.setTearOffEnabled(True)
 self.debuggerMenu.addActions(self.dbgActGrp.actions())
+# build the environment menu
+self.environmentMenu.setTearOffEnabled(True)
+self.environmentMenu.addActions(self.embeddedEnvironmentGrp.actions())
 # build the packagers menu
 self.packagersMenu.setTearOffEnabled(True)
 self.packagersMenu.addActions(self.pluginGrp.actions())
 self.packagersMenu.addSeparator()
 menu.addSeparator()
 menu.addAction(self.propsAct)
 menu.addAction(self.userPropsAct)
 menu.addAction(self.filetypesAct)
 menu.addAction(self.lexersAct)
+menu.addSeparator()
+self.menuEnvironmentAct = menu.addMenu(self.environmentMenu)
 menu.addSeparator()
 self.menuDebuggerAct = menu.addMenu(self.debuggerMenu)
 self.menuSessionAct = menu.addMenu(self.sessionMenu)
 # build the project tools menu
 self.menuApidocAct.setEnabled(False)
 self.menuPackagersAct.setEnabled(False)
 self.menuMakeAct.setEnabled(False)
 self.menuOtherToolsAct.setEnabled(False)
 self.menuFormattingAct.setEnabled(False)
+self.menuEnvironmentAct.setEnabled(False)
 self.__menu = menu
 self.__toolsMenu = toolsMenu
 return menu, toolsMenu
 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.showMenu.emit("Main", self.__menus["Main"])
 def __syncRecent(self):
 """
 def __showContextMenuFormat(self):
 """
 Private slot called before the 'Code Formatting' menu is shown.
 """
-self.showMenu.emit("Formatting", self.othersMenu)
+self.showMenu.emit("Formatting", self.formattingMenu)
 @pyqtSlot()
 def __aboutBlack(self):
 """
 Private slot to show some information about the installed 'Black' tool.
 from CodeFormatting.BlackFormattingDialog import BlackFormattingDialog
 if ericApp().getObject("ViewManager").checkAllDirty():
 dlg = BlackConfigurationDialog(withProject=True)
 if dlg.exec() == QDialog.DialogCode.Accepted:
-config = dlg.getConfiguration()
+config = dlg.getConfiguration(saveToProject=True)
 formattingDialog = BlackFormattingDialog(
 config,
 self.getProjectFiles("SOURCES", normalized=True),
 project=self,
 action=action,
 )
 formattingDialog.exec()
+@pyqtSlot()
+def __configureBlack(self):
+"""
+Private slot to enter the parameters for formatting the project sources with
+'Black'.
+"""
+from 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.
+#########################################################################
+## Below are methods implementing the 'Embedded Environment' support
+#########################################################################
+def __showContextMenuEnvironment(self):
+"""
+Private slot called before the 'Embedded Environment' menu is shown.
+"""
+self.showMenu.emit("Environment", self.environmentMenu)
+def __findEmbeddedEnvironment(self):
+"""
+Private method to find the path of the embedded virtual environment.
+@return path of the embedded virtual environment (empty if not found)
+@rtype str
+"""
+for venvPathName in (".venv", "venv", ".env", "env"):
+venvPath = os.path.join(self.getProjectPath(), venvPathName)
+if os.path.isdir(venvPath):
+return venvPath
+return ""
+def __setEmbeddedEnvironmentProjectConfig(self, value):
+"""
+Private method to set the embedded environment project configuration.
+@param value flag indicating an embedded environment
+@type bool
+"""
+if value != self.pdata["EMBEDDED_VENV"]:
+self.pdata["EMBEDDED_VENV"] = value
+self.setDirty(True)
+def __initVenvConfiguration(self):
+"""
+Private method to initialize the environment configuration.
+"""
+self.__venvConfiguration = {
+"name": "embedded environment",
+"interpreter": "",
+"exec_path": "",
+}
+def __createEmbeddedEnvironment(self):
+"""
+Private method to create the embedded virtual environment.
+"""
+pythonPath, ok = EricPathPickerDialog.getStrPath(
+None,
+self.tr("Python Executable"),
+self.tr("Enter the Python interpreter for the virtual environment:"),
+defaultDirectory=Globals.getPythonExecutable(),
+)
+if not ok:
+# user canceled the environment creation
+self.__setEmbeddedEnvironmentProjectConfig(False)
+return
+configuration = {
+"envType": "pyvenv",
+"targetDirectory": os.path.join(self.getProjectPath(), ".venv"),
+"openTarget": False,
+"createLog": True,
+"createScript": True,
+"logicalName": self.__venvConfiguration["name"],
+"pythonExe": pythonPath,
+}
+from VirtualEnv.VirtualenvExecDialog import VirtualenvExecDialog
+dia = VirtualenvExecDialog(configuration, None)
+dia.show()
+dia.start([configuration["targetDirectory"]])
+dia.exec()
+self.__configureEnvironment()
+if not self.__venvConfiguration["interpreter"]:
+# user canceled the environment creation
+self.__setEmbeddedEnvironmentProjectConfig(False)
+return
+@pyqtSlot()
+def __configureEnvironment(self, environmentPath=""):
+"""
+Private slot to configure the embedded environment.
+@param environmentPath path of the virtual environment (defaults to "")
+@type str (optional)
+"""
+from .ProjectVenvConfigurationDialog import ProjectVenvConfigurationDialog
+if not environmentPath:
+environmentPath = os.path.join(self.getProjectPath(), ".venv")
+dlg = ProjectVenvConfigurationDialog(
+self.__venvConfiguration["name"],
+environmentPath,
+self.__venvConfiguration["interpreter"],
+self.__venvConfiguration["exec_path"],
+)
+if dlg.exec() == QDialog.DialogCode.Accepted:
+(
+self.__venvConfiguration["interpreter"],
+self.__venvConfiguration["exec_path"],
+) = dlg.getData()
+self.__saveEnvironmentConfiguration()
+self.__setEmbeddedEnvironmentProjectConfig(True)
+elif not self.__venvConfiguration["interpreter"]:
+self.__setEmbeddedEnvironmentProjectConfig(False)
+def __installProjectIntoEnvironment(self):
+"""
+Private method to install the project into the embedded environment in
+development mode.
+"""
+pip = ericApp().getObject("Pip")
+pip.installEditableProject(self.getProjectInterpreter(), self.getProjectPath())
+def __saveEnvironmentConfiguration(self):
+"""
+Private method to save the embedded environment configuration.
+"""
+with contextlib.suppress(OSError), open(
+os.path.join(self.getProjectManagementDir(), "venv_config.json"), "w"
+) as f:
+json.dump(self.__venvConfiguration, f, indent=2)
+def __loadEnvironmentConfiguration(self):
+"""
+Private method to load the embedded environment configuration.
+"""
+try:
+with open(
+os.path.join(self.getProjectManagementDir(), "venv_config.json"), "r"
+) as f:
+self.__venvConfiguration = json.load(f)
+if not os.path.isfile(
+self.__venvConfiguration["interpreter"]
+) or not os.access(self.__venvConfiguration["interpreter"], os.X_OK):
+self.__venvConfiguration["interpreter"] = ""
+except (OSError, json.JSONDecodeError):
+# the configuration file does not exist or is invalid JSON
+self.__initVenvConfiguration()
 #
 # eflag: noqa = M601

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Project/Project.py

src/eric7/Project/Project.py