eric: comparison src/eric7/MicroPython/CircuitPythonDevices.py

-:5e05b2089daf
+:4ae976ee5339
 import os
 import shutil
 from PyQt6.QtCore import pyqtSlot
+from PyQt6.QtWidgets import QMenu
 from eric7 import Preferences
 from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.SystemUtilities import FileSystemUtilities
 Class implementing the device for CircuitPython boards.
 """
 DeviceVolumeName = "CIRCUITPY"
-def __init__(self, microPythonWidget, deviceType, parent=None):
+def __init__(self, microPythonWidget, deviceType, boardName, parent=None):
 """
 Constructor
 @param microPythonWidget reference to the main MicroPython widget
 @type MicroPythonWidget
 @param deviceType device type assigned to this device interface
 @type str
+@param boardName name of the board
+@type str
 @param parent reference to the parent object
 @type QObject
 """
 super().__init__(microPythonWidget, deviceType, parent)
+self.__boardName = boardName
 self.__workspace = self.__findWorkspace()
 self.__nonUF2devices = {
 "teensy": self.__flashTeensy,
 }
 return self.__workspace
 else:
 self.__workspace = self.__findWorkspace(silent=silent)
 return self.__workspace
+def __findDeviceDirectories(self, directories):
+"""
+Private method to find the device directories associated with the
+current board name.
+@param directories list of directories to be checked
+@type list of str
+@return list of associated directories
+@rtype list of str
+"""
+boardDirectories = []
+for directory in directories:
+bootFile = os.path.join(directory, "boot_out.txt")
+if os.path.exists(bootFile):
+with open(bootFile, "r") as f:
+line = f.readline()
+if self.__boardName in line:
+boardDirectories.append(directory)
+return boardDirectories
 def __findWorkspace(self, silent=False):
 """
 Private method to find the workspace directory.
 @param silent flag indicating silent operations
 if deviceDirectories:
 if len(deviceDirectories) == 1:
 return deviceDirectories[0]
 else:
-return self.selectDeviceDirectory(deviceDirectories)
+boardDirectories = self.__findDeviceDirectories(deviceDirectories)
+if len(boardDirectories) == 1:
+return boardDirectories[0]
+elif len(boardDirectories) > 1:
+return self.selectDeviceDirectory(boardDirectories)
+else:
+return self.selectDeviceDirectory(deviceDirectories)
 else:
 # return the default workspace and give the user a warning (unless
 # silent mode is selected)
 if not silent:
 EricMessageBox.warning(
 @param menu reference to the context menu
 @type QMenu
 """
 connected = self.microPython.isConnected()
+self.__libraryMenu = QMenu(self.tr("Library Management"))
+act = self.__libraryMenu.addAction(
+self.tr("Install Library Files"), self.__installLibraryFiles
+)
+act.setEnabled(self.__deviceVolumeMounted())
+act = self.__libraryMenu.addAction(
+self.tr("Install Library Package"),
+lambda: self.__installLibraryFiles(packageMode=True),
+)
+act.setEnabled(self.__deviceVolumeMounted())
 act = menu.addAction(
 self.tr("Flash CircuitPython Firmware"), self.__flashCircuitPython
 )
 act.setEnabled(not connected)
 menu.addSeparator()
-act = menu.addAction(
+menu.addMenu(self.__libraryMenu)
-self.tr("Install Library Files"), self.__installLibraryFiles
-)
-act.setEnabled(self.__deviceVolumeMounted())
 def hasFlashMenuEntry(self):
 """
 Public method to check, if the device has its own flash menu entry.
 """ for details.</p>"""
 ).format("https://www.pjrc.com/teensy/loader.html"),
 )
 @pyqtSlot()
-def __installLibraryFiles(self):
+def __installLibraryFiles(self, packageMode=False):
 """
 Private slot to install Python files into the onboard library.
-"""
+@param packageMode flag indicating to install a library package
+(defaults to False)
+@type bool (optional)
+"""
+title = (
+self.tr("Install Library Package")
+if packageMode
+else self.tr("Install Library Files")
+)
 if not self.__deviceVolumeMounted():
 EricMessageBox.critical(
 self.microPython,
-self.tr("Install Library Files"),
+title,
 self.tr(
 """The device volume "<b>{0}</b>" is not available."""
 """ Ensure it is mounted properly and try again."""
 ),
 )
 target = os.path.join(self.getWorkspace(), "lib")
 # ensure that the library directory exists on the device
 if not os.path.isdir(target):
 os.makedirs(target)
-libraryFiles = EricFileDialog.getOpenFileNames(
+if packageMode:
-self.microPython,
+libraryPackage = EricFileDialog.getExistingDirectory(
-self.tr("Install Library Files"),
+self.microPython,
-os.path.expanduser("~"),
+title,
-self.tr(
+os.path.expanduser("~"),
-"Compiled Python Files (*.mpy);;"
+EricFileDialog.Option(0),
-"Python Files (*.py);;"
+)
-"All Files (*)"
+if libraryPackage:
-),
+target = os.path.join(target, os.path.basename(libraryPackage))
-)
+shutil.rmtree(target, ignore_errors=True)
+shutil.copytree(libraryPackage, target)
-for libraryFile in libraryFiles:
+else:
-if os.path.exists(libraryFile):
+libraryFiles = EricFileDialog.getOpenFileNames(
-shutil.copy2(libraryFile, target)
+self.microPython,
+title,
+os.path.expanduser("~"),
+self.tr(
+"Compiled Python Files (*.mpy);;"
+"Python Files (*.py);;"
+"All Files (*)"
+),
+)
+for libraryFile in libraryFiles:
+if os.path.exists(libraryFile):
+shutil.copy2(libraryFile, target)
 def getDocumentationUrl(self):
 """
 Public method to get the device documentation URL.
 Preferences.getMicroPython("CircuitPythonLibrariesUrl"),
 ),
 ]
-def createDevice(microPythonWidget, deviceType, vid, pid):
+def createDevice(microPythonWidget, deviceType, vid, pid, boardName):
 """
 Function to instantiate a MicroPython device object.
 @param microPythonWidget reference to the main MicroPython widget
 @type MicroPythonWidget
 @type str
 @param vid vendor ID
 @type int
 @param pid product ID
 @type int
+@param boardName name of the board
+@type str
 @return reference to the instantiated device object
 @rtype CircuitPythonDevice
 """
-return CircuitPythonDevice(microPythonWidget, deviceType)
+return CircuitPythonDevice(microPythonWidget, deviceType, boardName)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/MicroPython/CircuitPythonDevices.py

src/eric7/MicroPython/CircuitPythonDevices.py