eric: comparison VirtualEnv/VirtualenvManager.py

-:d14ddbfbbd36
+:c6dda2cbe081
 import sys
 import shutil
 import json
 import copy
-from PyQt5.QtCore import pyqtSlot, QObject
+from PyQt5.QtCore import pyqtSlot, pyqtSignal, QObject
 from PyQt5.QtWidgets import QDialog
 from E5Gui import E5MessageBox
+from E5Gui.E5Application import e5App
 import Preferences
-import Utilities
 class VirtualenvManager(QObject):
 """
 Class implementing an object to manage Python virtual environments.
+@signal virtualEnvironmentAdded() emitted to indicate the addition of
+a virtual environment
+@signal virtualEnvironmentRemoved() emitted to indicate the removal and
+deletion of a virtual environment
+@signal virtualEnvironmentChanged(name) emitted to indicate a change of
+a virtual environment
 """
 DefaultKey = "<default>"
+virtualEnvironmentAdded = pyqtSignal()
+virtualEnvironmentRemoved = pyqtSignal()
+virtualEnvironmentChanged = pyqtSignal(str)
 def __init__(self, parent=None):
 """
 Constructor
 #                   (empty for a global environment)
 #   interpreter:    the path of the Python interpreter
 #   variant:        Python variant (2 or 3)
 #   is_global:      a flag indicating a global environment
 #   is_conda:       a flag indicating an Anaconda environment
+#   is_remote:      a flag indicating a remotely accessed environment
 #   exec_path:      a string to be prefixed to the PATH environment
 #                   setting
 #
 for venvName in environments:
-interpreter = environments[venvName]["interpreter"]
+environment = environments[venvName]
-if os.access(interpreter, os.X_OK):
+if ("is_remote" in environment and environment["is_remote"]) or \
-environment = environments[venvName]
+os.access(environment["interpreter"], os.X_OK):
 if "is_global" not in environment:
 environment["is_global"] = environment["path"] == ""
 if "is_conda" not in environment:
 environment["is_conda"] = False
+if "is_remote" not in environment:
+environment["is_remote"] = False
 if "exec_path" not in environment:
 environment["exec_path"] = ""
 self.__virtualEnvironments[venvName] = environment
 # check, if the interpreter used to run eric is in the environments
 "path": "",
 "interpreter": defaultPy,
 "variant": sys.version_info[0],
 "is_global": True,
 "is_conda": False,
+"is_remote": False,
 "exec_path": "",
 }
 self.__saveSettings()
 """
 Preferences.Prefs.settings.setValue(
 "PyVenv/VirtualEnvironments",
 json.dumps(self.__virtualEnvironments)
 )
+Preferences.syncPreferences()
 def getDefaultEnvironment(self):
 """
 Public method to get the default virtual environment.
 from .VirtualenvConfigurationDialog import \
 VirtualenvConfigurationDialog
 dlg = VirtualenvConfigurationDialog()
 if dlg.exec_() == QDialog.Accepted:
-(pyvenv, args, name, openTarget, createLog, createScript,
+resultDict = dlg.getData()
-targetDir, interpreter) = dlg.getData()
-# now do the call
+if resultDict["envType"] == "conda":
-from .VirtualenvExecDialog import VirtualenvExecDialog
+# create the conda environment
-dia = VirtualenvExecDialog(pyvenv, targetDir, name, openTarget,
+conda = e5App().getObject("Conda")
-createLog, createScript, interpreter,
+ok, prefix, interpreter = conda.createCondaEnvironment(
-self)
+resultDict["arguments"])
-dia.show()
+if ok and "--dry-run" not in resultDict["arguments"]:
-dia.start(args)
+self.addVirtualEnv(resultDict["logicalName"],
-dia.exec_()
+prefix,
+venvInterpreter=interpreter,
+isConda=True)
+else:
+# now do the call
+from .VirtualenvExecDialog import VirtualenvExecDialog
+dia = VirtualenvExecDialog(resultDict, self)
+dia.show()
+dia.start(resultDict["arguments"])
+dia.exec_()
 def addVirtualEnv(self, venvName, venvDirectory, venvInterpreter="",
 venvVariant=3, isGlobal=False, isConda=False,
-execPath=""):
+isRemote=False, execPath=""):
 """
 Public method to add a virtual environment.
 @param venvName logical name for the virtual environment
 @type str
 @param venvVariant Python variant of the virtual environment
 @type int
 @param isGlobal flag indicating a global environment
 @type bool
 @param isConda flag indicating an Anaconda virtual environment
+@type bool
+@param isRemote flag indicating a remotely accessed environment
 @type bool
 @param execPath search path string to be prepended to the PATH
 environment variable
 @type str
 """
 self.tr("""A virtual environment named <b>{0}</b> exists"""
 """ already. Shall it be replaced?""")
 .format(venvName),
 icon=E5MessageBox.Warning)
 if not ok:
-return
+from .VirtualenvNameDialog import VirtualenvNameDialog
+dlg = VirtualenvNameDialog(
+list(self.__virtualEnvironments.keys()),
+venvName)
+if dlg.exec_() != QDialog.Accepted:
+return
+venvName = dlg.getName()
 if not venvInterpreter:
 from .VirtualenvInterpreterSelectionDialog import \
 VirtualenvInterpreterSelectionDialog
 dlg = VirtualenvInterpreterSelectionDialog(venvName, venvDirectory)
 if dlg.exec_() == QDialog.Accepted:
 venvInterpreter, venvVariant = dlg.getData()
-if not Utilities.startswithPath(venvInterpreter,
-venvDirectory):
-isGlobal = True
 if venvInterpreter:
 self.__virtualEnvironments[venvName] = {
 "path": venvDirectory,
 "interpreter": venvInterpreter,
 "variant": venvVariant,
 "is_global": isGlobal,
 "is_conda": isConda,
+"is_remote": isRemote,
 "exec_path": execPath,
 }
 self.__saveSettings()
+self.virtualEnvironmentAdded.emit()
 if self.__virtualenvManagerDialog:
 self.__virtualenvManagerDialog.refresh()
 def setVirtualEnv(self, venvName, venvDirectory, venvInterpreter,
-venvVariant, isGlobal, isConda, execPath):
+venvVariant, isGlobal, isConda, isRemote,
+execPath):
 """
 Public method to change a virtual environment.
 @param venvName logical name of the virtual environment
 @type str
 @param venvVariant Python variant of the virtual environment
 @type int
 @param isGlobal flag indicating a global environment
 @type bool
 @param isConda flag indicating an Anaconda virtual environment
+@type bool
+@param isRemote flag indicating a remotely accessed environment
 @type bool
 @param execPath search path string to be prepended to the PATH
 environment variable
 @type str
 """
 "path": venvDirectory,
 "interpreter": venvInterpreter,
 "variant": venvVariant,
 "is_global": isGlobal,
 "is_conda": isConda,
+"is_remote": isRemote,
 "exec_path": execPath,
 }
 self.__saveSettings()
+self.virtualEnvironmentChanged.emit(venvName)
 if self.__virtualenvManagerDialog:
 self.__virtualenvManagerDialog.refresh()
 def renameVirtualEnv(self, oldVenvName, venvName, venvDirectory,
 venvInterpreter, venvVariant, isGlobal, isConda,
-execPath):
+isRemote, execPath):
 """
 Public method to substitute a virtual environment entry with a new
 name.
 @param oldVenvName old name of the virtual environment
 @param venvVariant Python variant of the virtual environment
 @type int
 @param isGlobal flag indicating a global environment
 @type bool
 @param isConda flag indicating an Anaconda virtual environment
+@type bool
+@param isRemote flag indicating a remotely accessed environment
 @type bool
 @param execPath search path string to be prepended to the PATH
 environment variable
 @type str
 """
 icon=E5MessageBox.Warning)
 return
 del self.__virtualEnvironments[oldVenvName]
 self.addVirtualEnv(venvName, venvDirectory, venvInterpreter,
-venvVariant, isGlobal, isConda, execPath)
+venvVariant, isGlobal, isConda, isRemote,
+execPath)
 def deleteVirtualEnvs(self, venvNames):
 """
 Public method to delete virtual environments from the list and disk.
 venvMessages
 )
 if dlg.exec_() == QDialog.Accepted:
 for venvName in venvNames:
 if self.__isEnvironmentDeleteable(venvName):
-shutil.rmtree(
+if self.isCondaEnvironment(venvName):
-self.__virtualEnvironments[venvName]["path"], True)
+conda = e5App().getObject("Conda")
-del self.__virtualEnvironments[venvName]
+path = self.__virtualEnvironments[venvName]["path"]
+res = conda.removeCondaEnvironment(prefix=path)
+if res:
+del self.__virtualEnvironments[venvName]
+else:
+shutil.rmtree(
+self.__virtualEnvironments[venvName]["path"],
+True)
+del self.__virtualEnvironments[venvName]
 self.__saveSettings()
+self.virtualEnvironmentRemoved.emit()
 if self.__virtualenvManagerDialog:
 self.__virtualenvManagerDialog.refresh()
 def __isEnvironmentDeleteable(self, venvName):
 """
 ok = False
 if venvName in self.__virtualEnvironments:
 ok = True
 ok &= bool(self.__virtualEnvironments[venvName]["path"])
 ok &= not self.__virtualEnvironments[venvName]["is_global"]
+ok &= not self.__virtualEnvironments[venvName]["is_remote"]
 ok &= os.access(self.__virtualEnvironments[venvName]["path"],
 os.W_OK)
 return ok
 if venvName in self.__virtualEnvironments:
 del self.__virtualEnvironments[venvName]
 self.__saveSettings()
+self.virtualEnvironmentRemoved.emit()
 if self.__virtualenvManagerDialog:
 self.__virtualenvManagerDialog.refresh()
 def getEnvironmentEntries(self):
 """
 if venvName in self.__virtualEnvironments:
 return self.__virtualEnvironments[venvName]["is_conda"]
 else:
 return False
+def isRemoteEnvironment(self, venvName):
+"""
+Public method to test, if a given environment is a remotely accessed
+environment.
+@param venvName logical name of the virtual environment
+@type str
+@return flag indicating a remotely accessed environment
+@rtype bool
+"""
+if venvName in self.__virtualEnvironments:
+return self.__virtualEnvironments[venvName]["is_remote"]
+else:
+return False
 def getVirtualenvExecPath(self, venvName):
 """
 Public method to get the search path prefix of a virtual environment.
 @param venvName logical name for the virtual environment

Mercurial Repositories > eric / file comparison

comparison: VirtualEnv/VirtualenvManager.py

VirtualEnv/VirtualenvManager.py