eric: comparison eric6/MicroPython/MicroPythonCommandsInterface.py

-:0835ed67714b
+:2f0d208b8137
 @param dirname name of the directory to be listed
 @type str
 @return tuple containg the directory listing
 @rtype tuple of str
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if self.__repl.isMicrobit():
 # BBC micro:bit does not support directories
 commands = [
 "import os as __os_",
 "print(__os_.listdir('{0}'))".format(dirname),
 "del __os_",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 return ast.literal_eval(out.decode("utf-8"))
 def lls(self, dirname="", fullstat=False, showHidden=False):
 """
 Public method to get a long directory listing of the connected device
 @return list containing the directory listing with tuple entries of
 the name and and a tuple of mode, size and time (if fullstat is
 false) or the complete stat() tuple. 'None' is returned in case the
 directory doesn't exist.
 @rtype tuple of (str, tuple)
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if self.__repl.isMicrobit():
 # BBC micro:bit does not support directories
 commands = [
 "import os as __os_",
 "print(listdir_stat('{0}', {1}))".format(dirname, showHidden),
 "del __os_, stat, listdir_stat, is_visible",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 fileslist = ast.literal_eval(out.decode("utf-8"))
 if fileslist is None:
 return None
 else:
 if fullstat:
 """
 Public method to change the current directory on the connected device.
 @param dirname directory to change to
 @type str
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if dirname:
 commands = [
 "import os as __os_",
 "__os_.chdir('{0}')".format(dirname),
 "del __os_",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 def pwd(self):
 """
 Public method to get the current directory of the connected device.
 @return current directory
 @rtype str
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if self.__repl.isMicrobit():
 # BBC micro:bit does not support directories
 return ""
 "print(__os_.getcwd())",
 "del __os_",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 return out.decode("utf-8").strip()
 def rm(self, filename):
 """
 Public method to remove a file from the connected device.
 @param filename name of the file to be removed
 @type str
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if filename:
 commands = [
 "import os as __os_",
 "__os_.remove('{0}')".format(filename),
 "del __os_",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 def rmrf(self, name, recursive=False, force=False):
 """
 Public method to remove a file or directory recursively.
 @type bool
 @param force flag indicating to ignore errors
 @type bool
 @return flag indicating success
 @rtype bool
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if name:
 commands = [
 "import os as __os_",
 "\n".join([
 force),
 "del __os_, remove_file",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 return ast.literal_eval(out.decode("utf-8"))
 return False
 def mkdir(self, dirname):
 """
 Public method to create a new directory.
 @param dirname name of the directory to create
 @type str
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if dirname:
 commands = [
 "import os as __os_",
 "__os_.mkdir('{0}')".format(dirname),
 "del __os_",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 def rmdir(self, dirname):
 """
 Public method to remove a directory.
 @param dirname name of the directory to be removed
 @type str
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if dirname:
 commands = [
 "import os as __os_",
 "__os_.rmdir('{0}')".format(dirname),
 "del __os_",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 def put(self, hostFileName, deviceFileName=None):
 """
 Public method to copy a local file to the connected device.
 @type str
 @param deviceFileName name of the file to copy to
 @type str
 @return flag indicating success
 @rtype bool
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if not os.path.isfile(hostFileName):
-raise IOError("No such file: {0}".format(hostFileName))
+raise OSError("No such file: {0}".format(hostFileName))
 with open(hostFileName, "rb") as hostFile:
 content = hostFile.read()
 # convert eol '\r'
 content = content.replace(b"\r\n", b"\r")
 "del f, fd",
 ])
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 return True
 def get(self, deviceFileName, hostFileName=None):
 """
 Public method to copy a file from the connected device.
 @type str
 @param hostFileName name of the file to copy to
 @type str
 @return flag indicating success
 @rtype bool
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 if not hostFileName:
 hostFileName = deviceFileName
 commands = [
 ]),
 "send_data()",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 # write the received bytes to the local file
 # convert eol to "\n"
 out = out.replace(b"\r\n", b"\n")
 out = out.replace(b"\r", b"\n")
 systems.
 @return tuple of tuples containing the file system name, the total
 size, the used size and the free size
 @rtype tuple of tuples of (str, int, int, int)
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 commands = [
 "import os as __os_",
 "\n".join([
 "def fsinfo():",
 "print(fsinfo())",
 "del __os_, fsinfo",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 infolist = ast.literal_eval(out.decode("utf-8"))
 if infolist is None:
 return None
 else:
 filesystemInfos = []
 Public method to get the MicroPython version information of the
 connected device.
 @return dictionary containing the version information
 @rtype dict
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 commands = [
 "import os as __os_",
 "print(__os_.uname())",
 "del __os_",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 rawOutput = out.decode("utf-8").strip()
 rawOutput = rawOutput[1:-1]
 items = rawOutput.split(",")
 result = {}
 Public method to get some implementation information of the connected
 device.
 @return dictionary containing the implementation information
 @rtype dict
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 commands = [
 "import sys as __sys_",
 "res = {}",                             # __IGNORE_WARNING_M613__
 "\n".join([
 "print(res)",
 "del res, __sys_",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 return ast.literal_eval(out.decode("utf-8"))
 def syncTime(self):
 """
 Public method to set the time of the connected device to the local
 computer's time.
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 now = time.localtime(time.time())
 commands = [
 "\n".join([
 "def set_time(rtc_time):",
 now.tm_wday)),
 "del set_time",
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 def getTime(self):
 """
 Public method to get the current time of the device.
 @return time of the device
 @rtype str
-@exception IOError raised to indicate an issue with the device
+@exception OSError raised to indicate an issue with the device
 """
 commands = [
 "import time as __time_",
 "\n".join([
 "try:",
 ]),
 "del __time_"
 ]
 out, err = self.execute(commands)
 if err:
-raise IOError(self.__shortError(err))
+raise OSError(self.__shortError(err))
 return out.decode("utf-8").strip()

Mercurial Repositories > eric / file comparison

comparison: eric6/MicroPython/MicroPythonCommandsInterface.py

eric6/MicroPython/MicroPythonCommandsInterface.py