eric: comparison VirtualEnv/VirtualenvManager.py

-:d6c0b8ab1fc6
+:17b3c75913de
 from __future__ import unicode_literals
 import os
 import sys
 import shutil
+import json
+import copy
 from PyQt5.QtCore import pyqtSlot, QObject
 from PyQt5.QtWidgets import QDialog
 from E5Gui import E5MessageBox
 """
 super(VirtualenvManager, self).__init__(parent)
 self.__ui = parent
+self.__loadSettings()
+self.__virtualenvManagerDialog = None
+def __loadSettings(self):
+"""
+Private slot to load the virtual environments.
+"""
+venvString = Preferences.Prefs.settings.value(
+"PyVenv/VirtualEnvironments", "{}")     # __IGNORE_WARNING_M613__
+environments = json.loads(venvString)
 self.__virtualEnvironments = {}
-self.__virtualEnvironmentInterpreters = {}
+# each environment entry is a dictionary:
-environments = Preferences.toDict(Preferences.Prefs.settings.value(
+#   path:           the directory of the virtual environment
-"PyVenv/Environments", {}))
+#                   (empty for a global environment)
-interpreters = Preferences.toDict(Preferences.Prefs.settings.value(
+#   interpreter:    the path of the Python interpreter
-"PyVenv/Interpreters", {}))
+#   variant:        Python variant (2 or 3)
-for venvName, venvExe in interpreters.items():
+#
-# remove all environments, that don't exist anymore
+for venvName in environments:
-if os.access(venvExe, os.X_OK):
+interpreter = environments[venvName]["interpreter"]
-self.__virtualEnvironmentInterpreters[venvName] = venvExe
+if os.access(interpreter, os.X_OK):
 self.__virtualEnvironments[venvName] = environments[venvName]
+# check, if the interpreter used to run eric is in the environments
 defaultPy = sys.executable.replace("w.exe", ".exe")
-if defaultPy not in self.__virtualEnvironmentInterpreters.values():
+found = False
-self.__virtualEnvironmentInterpreters["<default>"] = defaultPy
+for venvName in self.__virtualEnvironments:
-self.__virtualEnvironments["<default>"] = ""
+if (defaultPy ==
+self.__virtualEnvironments[venvName]["interpreter"]):
-self.__updateSettings()
+found = True
+break
-self.__virtualenvManagerDialog = None
+if not found:
+# add an environment entry for the default interpreter
-def __updateSettings(self):
+self.__virtualEnvironments["<default>"] = {
+"path": "",
+"interpreter": defaultPy,
+"variant": sys.version_info[0],
+}
+self.__saveSettings()
+def __saveSettings(self):
 """
 Private slot to save the virtual environments.
 """
 Preferences.Prefs.settings.setValue(
-"PyVenv/Environments", self.__virtualEnvironments)
+"PyVenv/VirtualEnvironments",
-Preferences.Prefs.settings.setValue(
+json.dumps(self.__virtualEnvironments)
-"PyVenv/Interpreters", self.__virtualEnvironmentInterpreters)
+)
 @pyqtSlot()
 def createVirtualEnv(self):
 """
 Public slot to create a new virtual environment.
 self)
 dia.show()
 dia.start(args)
 dia.exec_()
-def addVirtualEnv(self, venvName, venvDirectory, venvInterpreter=""):
+def addVirtualEnv(self, venvName, venvDirectory, venvInterpreter="",
+venvVariant=3):
 """
 Public method to add a virtual environment.
 @param venvName logical name for the virtual environment
 @type str
 @param venvDirectory directory of the virtual environment
 @type str
 @param venvInterpreter interpreter of the virtual environment
+@type str
+@param venvVariant Python variant of the virtual environment
+@type int
 """
 if venvName in self.__virtualEnvironments:
 ok = E5MessageBox.yesNo(
 None,
 self.tr("Add Virtual Environment"),
 if not venvInterpreter:
 from .VirtualenvInterpreterSelectionDialog import \
 VirtualenvInterpreterSelectionDialog
 dlg = VirtualenvInterpreterSelectionDialog(venvName, venvDirectory)
 if dlg.exec_() == QDialog.Accepted:
-venvInterpreter = dlg.getData()
+venvInterpreter, venvVariant = dlg.getData()
 if venvInterpreter:
-self.__virtualEnvironmentInterpreters[venvName] = venvInterpreter
+self.__virtualEnvironments[venvName] = {
-self.__virtualEnvironments[venvName] = venvDirectory
+"path": venvDirectory,
+"interpreter": venvInterpreter,
+"variant": venvVariant,
+}
-self.__updateSettings()
+self.__saveSettings()
 if self.__virtualenvManagerDialog:
 self.__virtualenvManagerDialog.refresh()
-def setVirtualEnv(self, venvName, venvDirectory, venvInterpreter=""):
+def setVirtualEnv(self, venvName, venvDirectory, venvInterpreter,
+venvVariant):
 """
 Public method to change a virtual environment.
 @param venvName logical name of the virtual environment
 @type str
 @param venvDirectory directory of the virtual environment
 @type str
 @param venvInterpreter interpreter of the virtual environment
+@type str
+@param venvVariant Python variant of the virtual environment
+@type int
 """
 if venvName not in self.__virtualEnvironments:
 E5MessageBox.yesNo(
 None,
 self.tr("Change Virtual Environment"),
 """ exist. Aborting!""")
 .format(venvName),
 icon=E5MessageBox.Warning)
 return
-self.__virtualEnvironmentInterpreters[venvName] = venvInterpreter
+self.__virtualEnvironments[venvName] = {
-self.__virtualEnvironments[venvName] = venvDirectory
+"path": venvDirectory,
+"interpreter": venvInterpreter,
-self.__updateSettings()
+"variant": venvVariant,
+}
+self.__saveSettings()
 if self.__virtualenvManagerDialog:
 self.__virtualenvManagerDialog.refresh()
 def renameVirtualEnv(self, oldVenvName, venvName, venvDirectory,
-venvInterpreter):
+venvInterpreter, venvVariant):
 """
 Public method to substitute a virtual environment entry with a new
 name.
 @param oldVenvName old name of the virtual environment
 @param venvName logical name for the virtual environment
 @type str
 @param venvDirectory directory of the virtual environment
 @type str
 @param venvInterpreter interpreter of the virtual environment
+@type str
+@param venvVariant Python variant of the virtual environment
+@type int
 """
 if oldVenvName not in self.__virtualEnvironments:
 E5MessageBox.yesNo(
 None,
 self.tr("Rename Virtual Environment"),
 .format(oldVenvName),
 icon=E5MessageBox.Warning)
 return
 del self.__virtualEnvironments[oldVenvName]
-del self.__virtualEnvironmentInterpreters[oldVenvName]
+self.addVirtualEnv(venvName, venvDirectory, venvInterpreter,
-self.addVirtualEnv(venvName, venvDirectory, venvInterpreter)
+venvVariant)
 def deleteVirtualEnvs(self, venvNames):
 """
 Public method to delete virtual environments from the list and disk.
 @type list of str
 """
 venvMessages = []
 for venvName in venvNames:
 if venvName in self.__virtualEnvironments and \
-bool(self.__virtualEnvironments[venvName]):
+bool(self.__virtualEnvironments[venvName]["path"]):
 venvMessages.append(self.tr("{0} - {1}").format(
-venvName, self.__virtualEnvironments[venvName]))
+venvName, self.__virtualEnvironments[venvName]["path"]))
 if venvMessages:
 from UI.DeleteFilesConfirmationDialog import \
 DeleteFilesConfirmationDialog
 dlg = DeleteFilesConfirmationDialog(
 None,
 venvMessages
 )
 if dlg.exec_() == QDialog.Accepted:
 for venvName in venvNames:
 if venvName in self.__virtualEnvironments and \
-bool(self.__virtualEnvironments[venvName]):
+bool(self.__virtualEnvironments[venvName]["path"]):
-shutil.rmtree(self.__virtualEnvironments[venvName],
+shutil.rmtree(
-True)
+self.__virtualEnvironments[venvName]["path"], True)
 del self.__virtualEnvironments[venvName]
-del self.__virtualEnvironmentInterpreters[venvName]
-self.__updateSettings()
+self.__saveSettings()
 if self.__virtualenvManagerDialog:
 self.__virtualenvManagerDialog.refresh()
 def removeVirtualEnvs(self, venvNames):
 """
 venvMessages = []
 for venvName in venvNames:
 if venvName in self.__virtualEnvironments:
 venvMessages.append(self.tr("{0} - {1}").format(
-venvName, self.__virtualEnvironments[venvName]))
+venvName, self.__virtualEnvironments[venvName]["path"]))
 if venvMessages:
 from UI.DeleteFilesConfirmationDialog import \
 DeleteFilesConfirmationDialog
 dlg = DeleteFilesConfirmationDialog(
 None,
 )
 if dlg.exec_() == QDialog.Accepted:
 for venvName in venvNames:
 if venvName in self.__virtualEnvironments:
 del self.__virtualEnvironments[venvName]
-del self.__virtualEnvironmentInterpreters[venvName]
-self.__updateSettings()
+self.__saveSettings()
 if self.__virtualenvManagerDialog:
 self.__virtualenvManagerDialog.refresh()
 def getEnvironmentEntries(self):
 """
-Public method to a dictionary containing the defined virtual
+Public method to get a dictionary containing the defined virtual
 environment entries.
-@return dictionary containing tuples of the environment path and
+@return dictionary containing a copy of the defined virtual
-the associated interpreter
+environments
-@rtype dict of (str, str)
+@rtype dict
 """
-environments = {}
+return copy.deepcopy(self.__virtualEnvironments)
-for venvName in self.__virtualEnvironments:
-environments[venvName] = (
-self.__virtualEnvironments[venvName],
-self.__virtualEnvironmentInterpreters[venvName],
-)
-return environments
 @pyqtSlot()
 def showVirtualenvManagerDialog(self):
 """
 Public slot to show the virtual environment manager dialog.
 @param venvName logical name for the virtual environment
 @type str
 @return interpreter path
 @rtype str
 """
-if venvName in self.__virtualEnvironmentInterpreters:
+if venvName in self.__virtualEnvironments:
-return self.__virtualEnvironmentInterpreters[venvName]
+return self.__virtualEnvironments[venvName]["interpreter"]
 else:
 return ""
 def getVirtualenvDirectory(self, venvName):
 """
 @type str
 @return directory path
 @rtype str
 """
 if venvName in self.__virtualEnvironments:
-return self.__virtualEnvironments[venvName]
+return self.__virtualEnvironments[venvName]["path"]
 else:
 return ""
 def getVirtualenvNames(self):
 """
 Public method to get a list of defined virtual environments.
 @return list of defined virtual environments
 @rtype list of str
 """
-return list(self.__virtualEnvironmentInterpreters.keys())
+return list(self.__virtualEnvironments.keys())
+def getVirtualenvNamesForVariant(self, variant):
+"""
+Public method to get a list of virtual environments for a given
+Python variant.
+@param variant Python variant (2 or 3)
+@type int
+@return list of defined virtual environments
+@rtype list of str
+"""
+assert variant in (2, 3)
+environments = []
+for venvName in self.__virtualEnvironments:
+if self.__virtualEnvironments[venvName]["variant"] == variant:
+environments.append(venvName)
+return environments

Mercurial Repositories > eric / file comparison

comparison: VirtualEnv/VirtualenvManager.py

VirtualEnv/VirtualenvManager.py