eric: comparison src/eric7/VirtualEnv/VirtualenvManager.py

-:0d7392e49c48
+:2c26b4fe25db
 from eric7 import Preferences
 from eric7.EricWidgets import EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.SystemUtilities import FileSystemUtilities, PythonUtilities
 from eric7.UI.DeleteFilesConfirmationDialog import DeleteFilesConfirmationDialog
+from .VirtualenvMeta import VirtualenvMetaData
 class VirtualenvManager(QObject):
 """
 Class implementing an object to manage Python virtual environments.
 #   is_remote:      a flag indicating a remotely accessed environment
 #   exec_path:      a string to be prefixed to the PATH environment
 #                   setting
 #   description     a description of the environment
 #
-envsToDelete = []
 for venvName in environments:
 environment = environments[venvName]
+environment["name"] = venvName
 if ("is_remote" in environment and environment["is_remote"]) or os.access(
 environment["interpreter"], os.X_OK
 ):
 if "is_global" not in environment:
 environment["is_global"] = environment["path"] == ""
-if "is_conda" not in environment:
+self.__virtualEnvironments[venvName] = VirtualenvMetaData.from_dict(
-environment["is_conda"] = False
+environment
-if "is_remote" not in environment:
+)
-environment["is_remote"] = False
-if "exec_path" not in environment:
-environment["exec_path"] = ""
-if "description" not in environment:
-environment["description"] = ""
-self.__virtualEnvironments[venvName] = environment
-# now remove unsupported environments
-for venvName in envsToDelete:
-del environments[venvName]
 # check, if the interpreter used to run eric is in the environments
 defaultPy = PythonUtilities.getPythonExecutable()
 if "{0}.venv{0}".format(os.sep) not in defaultPy:
 # only check for a non-embedded environment
 ):
 found = True
 break
 if not found:
 # add an environment entry for the default interpreter
-self.__virtualEnvironments[VirtualenvManager.DefaultKey] = {
+self.__virtualEnvironments[
-"path": "",
+VirtualenvManager.DefaultKey
-"interpreter": defaultPy,
+] = VirtualenvMetaData(
-"variant": 3,
+name=VirtualenvManager.DefaultKey,
-"is_global": True,
+interpreter=defaultPy,
-"is_conda": False,
+is_globa=True,
-"is_remote": False,
+)
-"exec_path": "",
-"description": "",
-}
 self.__saveSettings()
 def __saveSettings(self):
 """
 Preferences.getSettings().setValue(
 "PyVenv/VirtualEnvironmentsBaseDir", self.__virtualEnvironmentsBaseDir
 )
 Preferences.getSettings().setValue(
-"PyVenv/VirtualEnvironments", json.dumps(self.__virtualEnvironments)
+"PyVenv/VirtualEnvironments",
+json.dumps(
+{env.name: env.as_dict() for env in self.__virtualEnvironments.values()}
+),
 )
 Preferences.syncPreferences()
 @pyqtSlot()
 def reloadSettings(self):
 Default is an environment with the key '<default>' or the first one
 having an interpreter matching sys.executable (i.e. the one used to
 execute eric with)
-@return tuple containing the environment name and a dictionary
+@return tuple containing the environment name and a copy of the metadata
-containing a copy of the default virtual environment
+of the default virtual environment
-@rtype tuple of (str, dict)
+@rtype tuple of (str, VirtualenvMetaData)
 """
 if VirtualenvManager.DefaultKey in self.__virtualEnvironments:
 return (
 VirtualenvManager.DefaultKey,
 copy.copy(self.__virtualEnvironments[VirtualenvManager.DefaultKey]),
 """
 Public method to get the environment a given interpreter belongs to.
 @param interpreter path of the interpreter
 @type str
-@return tuple containing the environment name and a dictionary
+@return tuple containing the environment name and a copy of the metadata
-containing a copy of the default virtual environment
+of the virtual environment the interpreter belongs to
-@rtype tuple of (str, dict)
+@rtype tuple of (str, VirtualenvMetaData)
 """
 py = FileSystemUtilities.normcaseabspath(interpreter.replace("w.exe", ".exe"))
 for venvName in self.__virtualEnvironments:
 if py == FileSystemUtilities.normcaseabspath(
-self.__virtualEnvironments[venvName]["interpreter"]
+self.__virtualEnvironments[venvName].interpreter
 ):
 return (venvName, copy.copy(self.__virtualEnvironments[venvName]))
 if os.path.samefile(interpreter, sys.executable):
 return (VirtualenvManager.SystemKey, {})
 ok, prefix, interpreter = conda.createCondaEnvironment(
 resultDict["arguments"]
 )
 if ok and "--dry-run" not in resultDict["arguments"]:
 self.addVirtualEnv(
-resultDict["logicalName"],
+VirtualenvMetaData(
-prefix,
+name=resultDict["logicalName"],
-venvInterpreter=interpreter,
+path=prefix,
-isConda=True,
+interpreter=interpreter,
+is_conda=True,
+)
 )
 else:
 # now do the call
 dia = VirtualenvExecDialog(resultDict, self)
 dia.show()
 dia = VirtualenvUpgradeExecDialog(venvName, pythonExe, createLog, self)
 dia.show()
 dia.start(args)
 dia.exec()
-def addVirtualEnv(
+def addVirtualEnv(self, metadata):
-self,
-venvName,
-venvDirectory,
-venvInterpreter="",
-isGlobal=False,
-isConda=False,
-isRemote=False,
-execPath="",
-description="",
-):
 """
 Public method to add a virtual environment.
-@param venvName logical name for the virtual environment
+@param metadata object containing the metadata of the virtual environment
-@type str
+@type VirtualenvMetaData
-@param venvDirectory directory of the virtual environment
-@type str
-@param venvInterpreter interpreter of the virtual environment
-@type str
-@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
-@param description descriptive text for the environment
-@type str
 """
 from .VirtualenvInterpreterSelectionDialog import (
 VirtualenvInterpreterSelectionDialog,
 )
 from .VirtualenvNameDialog import VirtualenvNameDialog
-if venvName in self.__virtualEnvironments:
+if metadata.name in self.__virtualEnvironments:
 ok = EricMessageBox.yesNo(
 None,
 self.tr("Add Virtual Environment"),
 self.tr(
 """A virtual environment named <b>{0}</b> exists"""
 """ already. Shall it be replaced?"""
-).format(venvName),
+).format(metadata.name),
 icon=EricMessageBox.Warning,
 )
 if not ok:
 dlg = VirtualenvNameDialog(
-list(self.__virtualEnvironments.keys()), venvName
+list(self.__virtualEnvironments.keys()), metadata.name
 )
 if dlg.exec() != QDialog.DialogCode.Accepted:
 return
-venvName = dlg.getName()
+metadata.name = dlg.getName()
-if not venvInterpreter:
+if not metadata.interpreter:
-dlg = VirtualenvInterpreterSelectionDialog(venvName, venvDirectory)
+dlg = VirtualenvInterpreterSelectionDialog(metadata.name, metadata.path)
 if dlg.exec() == QDialog.DialogCode.Accepted:
-venvInterpreter = dlg.getData()
+metadata.interpreter = dlg.getData()
-if venvInterpreter:
+if metadata.interpreter:
-self.__virtualEnvironments[venvName] = {
+self.__virtualEnvironments[metadata.name] = metadata
-"path": venvDirectory,
-"interpreter": venvInterpreter,
-"variant": 3,  # always 3
-"is_global": isGlobal,
-"is_conda": isConda,
-"is_remote": isRemote,
-"exec_path": execPath,
-"description": description,
-}
 self.__saveSettings()
 self.virtualEnvironmentAdded.emit()
 self.virtualEnvironmentsListChanged.emit()
-def setVirtualEnv(
+def setVirtualEnv(self, metadata):
-self,
-venvName,
-venvDirectory,
-venvInterpreter,
-isGlobal,
-isConda,
-isRemote,
-execPath,
-description,
-):
 """
 Public method to change a virtual environment.
-@param venvName logical name of the virtual environment
+@param metadata object containing the metadata of the virtual environment
-@type str
+@type VirtualenvMetaData
-@param venvDirectory directory of the virtual environment
+"""
-@type str
+if metadata.name not in self.__virtualEnvironments:
-@param venvInterpreter interpreter of the virtual environment
-@type str
-@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
-@param description descriptive text for the environment
-@type str
-"""
-if venvName not in self.__virtualEnvironments:
 EricMessageBox.yesNo(
 None,
 self.tr("Change Virtual Environment"),
 self.tr(
 """A virtual environment named <b>{0}</b> does not"""
 """ exist. Aborting!"""
-).format(venvName),
+).format(metadata.name),
 icon=EricMessageBox.Warning,
 )
 return
-self.__virtualEnvironments[venvName] = {
+self.__virtualEnvironments[metadata.name] = metadata
-"path": venvDirectory,
-"interpreter": venvInterpreter,
-"variant": 3,  # always 3
-"is_global": isGlobal,
-"is_conda": isConda,
-"is_remote": isRemote,
-"exec_path": execPath,
-"description": description,
-}
 self.__saveSettings()
-self.virtualEnvironmentChanged.emit(venvName)
+self.virtualEnvironmentChanged.emit(metadata.name)
 self.virtualEnvironmentsListChanged.emit()
 def renameVirtualEnv(
 self,
 oldVenvName,
-venvName,
+metadata,
-venvDirectory,
-venvInterpreter,
-isGlobal,
-isConda,
-isRemote,
-execPath,
-description,
 ):
 """
 Public method to substitute a virtual environment entry with a new
 name.
 @param oldVenvName old name of the virtual environment
 @type str
-@param venvName logical name for the virtual environment
+@param metadata object containing the metadata of the virtual environment
-@type str
+@type VirtualenvMetaData
-@param venvDirectory directory of the virtual environment
-@type str
-@param venvInterpreter interpreter of the virtual environment
-@type str
-@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
-@param description descriptive text for the environment
-@type str
 """
 if oldVenvName not in self.__virtualEnvironments:
 EricMessageBox.yesNo(
 None,
 self.tr("Rename Virtual Environment"),
 icon=EricMessageBox.Warning,
 )
 return
 del self.__virtualEnvironments[oldVenvName]
-self.addVirtualEnv(
+self.addVirtualEnv(metadata)
-venvName,
-venvDirectory,
-venvInterpreter=venvInterpreter,
-isGlobal=isGlobal,
-isConda=isConda,
-isRemote=isRemote,
-execPath=execPath,
-description=description,
-)
 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]["path"]
+self.__virtualEnvironments[venvName].path
 ):
 venvMessages.append(
 self.tr("{0} - {1}").format(
-venvName, self.__virtualEnvironments[venvName]["path"]
+venvName, self.__virtualEnvironments[venvName].path
 )
 )
 if venvMessages:
 dlg = DeleteFilesConfirmationDialog(
 None,
 if dlg.exec() == QDialog.DialogCode.Accepted:
 for venvName in venvNames:
 if self.__isEnvironmentDeleteable(venvName):
 if self.isCondaEnvironment(venvName):
 conda = ericApp().getObject("Conda")
-path = self.__virtualEnvironments[venvName]["path"]
+path = self.__virtualEnvironments[venvName].path
 res = conda.removeCondaEnvironment(prefix=path)
 if res:
 del self.__virtualEnvironments[venvName]
 else:
 shutil.rmtree(
-self.__virtualEnvironments[venvName]["path"], True
+self.__virtualEnvironments[venvName].path, True
 )
 del self.__virtualEnvironments[venvName]
 self.__saveSettings()
 @rtype bool
 """
 ok = False
 if venvName in self.__virtualEnvironments:
 ok = True
-ok &= bool(self.__virtualEnvironments[venvName]["path"])
+ok &= bool(self.__virtualEnvironments[venvName].path)
-ok &= not self.__virtualEnvironments[venvName]["is_global"]
+ok &= not self.__virtualEnvironments[venvName].is_global
-ok &= not self.__virtualEnvironments[venvName]["is_remote"]
+ok &= not self.__virtualEnvironments[venvName].is_remote
-ok &= os.access(self.__virtualEnvironments[venvName]["path"], os.W_OK)
+ok &= os.access(self.__virtualEnvironments[venvName].path, os.W_OK)
 return ok
 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]["path"]
+venvName, self.__virtualEnvironments[venvName].path
 )
 )
 if venvMessages:
 dlg = DeleteFilesConfirmationDialog(
 None,
 self.virtualEnvironmentRemoved.emit()
 self.virtualEnvironmentsListChanged.emit()
 def getEnvironmentEntries(self):
 """
-Public method to get a dictionary containing the defined virtual
+Public method to get a list of the defined virtual environment entries.
-environment entries.
+@return list containing a copy of the defined virtual environments
-@return dictionary containing a copy of the defined virtual
+@rtype list
-environments
+"""
-@rtype dict
+return [copy.copy(env) for env in self.__virtualEnvironments.values()]
-"""
-return copy.deepcopy(self.__virtualEnvironments)
 @pyqtSlot()
 def showVirtualenvManagerDialog(self, modal=False):
 """
 Public slot to show the virtual environment manager dialog.
 @type str
 @return interpreter path
 @rtype str
 """
 if venvName in self.__virtualEnvironments:
-return self.__virtualEnvironments[venvName]["interpreter"].replace(
+return self.__virtualEnvironments[venvName].interpreter.replace(
 "w.exe", ".exe"
 )
 elif venvName == VirtualenvManager.SystemKey:
 return sys.executable.replace("w.exe", ".exe")
 else:
 @type str
 @param venvInterpreter interpreter path to be set
 @type str
 """
 if venvName in self.__virtualEnvironments:
-self.__virtualEnvironments[venvName]["interpreter"] = venvInterpreter
+self.__virtualEnvironments[venvName].interpreter = venvInterpreter
 self.__saveSettings()
 self.virtualEnvironmentChanged.emit(venvName)
 self.virtualEnvironmentsListChanged.emit()
 @type str
 @return directory path
 @rtype str
 """
 if venvName in self.__virtualEnvironments:
-return self.__virtualEnvironments[venvName]["path"]
+return self.__virtualEnvironments[venvName].path
 else:
 return ""
 def getVirtualenvNames(self, noRemote=False, noConda=False):
 """
 @type str
 @return flag indicating a global environment
 @rtype bool
 """
 if venvName in self.__virtualEnvironments:
-return self.__virtualEnvironments[venvName]["is_global"]
+return self.__virtualEnvironments[venvName].is_global
 else:
 return False
 def isCondaEnvironment(self, venvName):
 """
 @type str
 @return flag indicating an Anaconda environment
 @rtype bool
 """
 if venvName in self.__virtualEnvironments:
-return self.__virtualEnvironments[venvName]["is_conda"]
+return self.__virtualEnvironments[venvName].is_conda
 else:
 return False
 def isRemoteEnvironment(self, venvName):
 """
 @type str
 @return flag indicating a remotely accessed environment
 @rtype bool
 """
 if venvName in self.__virtualEnvironments:
-return self.__virtualEnvironments[venvName]["is_remote"]
+return self.__virtualEnvironments[venvName].is_remote
 else:
 return False
 def getVirtualenvExecPath(self, venvName):
 """
 @type str
 @return search path prefix
 @rtype str
 """
 if venvName in self.__virtualEnvironments:
-return self.__virtualEnvironments[venvName]["exec_path"]
+return self.__virtualEnvironments[venvName].exec_path
 else:
 return ""
 def setVirtualEnvironmentsBaseDir(self, baseDir):
 """

Mercurial Repositories > eric / file comparison

comparison: src/eric7/VirtualEnv/VirtualenvManager.py

src/eric7/VirtualEnv/VirtualenvManager.py