mpytool 2.1.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

mpytool/conn_serial.py

@@ -6,7 +6,7 @@ import mpytool.conn as _conn
 
 
 class ConnSerial(_conn.Conn):
-    RECONNECT_TIMEOUT = 5  # seconds
+    RECONNECT_TIMEOUT = 10  # seconds
 
     def __init__(self, log=None, **serial_config):
         super().__init__(log)
@@ -28,14 +28,24 @@ class ConnSerial(_conn.Conn):
 
     def _read_available(self):
         """Read available data from serial port"""
-        in_waiting = self._serial.in_waiting
-        if in_waiting > 0:
-            return self._serial.read(in_waiting)
-        return None
+        if self._serial is None:
+            raise _conn.ConnError("Not connected")
+        try:
+            in_waiting = self._serial.in_waiting
+            if in_waiting > 0:
+                return self._serial.read(in_waiting)
+            return None
+        except OSError as err:
+            raise _conn.ConnError(f"Connection lost: {err}") from err
 
     def _write_raw(self, data):
         """Write data to serial port"""
-        return self._serial.write(data)
+        if self._serial is None:
+            raise _conn.ConnError("Not connected")
+        try:
+            return self._serial.write(data)
+        except OSError as err:
+            raise _conn.ConnError(f"Connection lost: {err}") from err
 
     def _is_usb_cdc(self):
         """Check if this is a USB-CDC port (native USB on ESP32-S/C)"""

mpytool/mpy.py

@@ -65,7 +65,8 @@ def _mt_tree(p):
 def _mt_mkdir(p):
     p=p.rstrip('/');c='';f=1
     for d in p.split('/'):
-        c+='/'+d if c else d
+        if not d:c='/';continue
+        c='/'+d if c=='/' else (c+'/'+d if c else d)
         if f:
             try:
                 if os.stat(c)[0]=={_ATTR_FILE}:return 1
@@ -295,6 +296,27 @@ def _mt_pfind(label):
         self.import_module('os')
         self._mpy_comm.exec(f"os.rename('{_escape_path(src)}', '{_escape_path(dst)}')")
 
+    def getcwd(self):
+        """Get current working directory
+
+        Returns:
+            current working directory path
+        """
+        self.import_module('os')
+        return self._mpy_comm.exec_eval("repr(os.getcwd())")
+
+    def chdir(self, path):
+        """Change current working directory
+
+        Arguments:
+            path: directory path to change to
+        """
+        self.import_module('os')
+        try:
+            self._mpy_comm.exec(f"os.chdir('{_escape_path(path)}')")
+        except _mpy_comm.CmdError as err:
+            raise DirNotFound(path) from err
+
     def hashfile(self, path):
         """Compute SHA256 hash of file
 
@@ -1124,11 +1146,12 @@ def _mt_pfind(label):
         self._mpy_comm.soft_reset_raw()
         self.reset_state()
 
-    def machine_reset(self, reconnect=True):
+    def machine_reset(self, reconnect=True, timeout=None):
         """MCU reset using machine.reset()
 
         Arguments:
             reconnect: if True, attempt to reconnect after reset
+            timeout: reconnect timeout in seconds (None = default)
 
         Returns:
             True if reconnected successfully, False otherwise
@@ -1139,7 +1162,7 @@ def _mt_pfind(label):
         self._conn.write(b"import machine; machine.reset()\x04")
         self.reset_state()
         if reconnect:
-            self._conn.reconnect()
+            self._conn.reconnect(timeout=timeout)
             return True
         return False
 

mpytool/mpytool.py

@@ -23,6 +23,38 @@ class ParamsError(_mpytool.MpyError):
     """Invalid command parameters"""
 
 
+def _join_remote_path(base, name):
+    """Join remote path components (handles empty string and '/' correctly)"""
+    if not name:
+        return base
+    if base == '/':
+        return '/' + name
+    elif base:
+        return base + '/' + name
+    else:
+        return name
+
+
+def _remote_basename(path):
+    """Get basename from remote path"""
+    return path.rstrip('/').split('/')[-1]
+
+
+def _parse_device_path(path, cmd_name):
+    """Parse device path with : prefix, raise ParamsError if missing
+
+    Args:
+        path: path string (should start with :)
+        cmd_name: command name for error message
+
+    Returns:
+        path without : prefix
+    """
+    if not path.startswith(':'):
+        raise ParamsError(f'{cmd_name} requires device path (: prefix): {path}')
+    return path[1:]
+
+
 class MpyTool():
     SPACE = '   '
     BRANCH = '│  '
@@ -128,7 +160,11 @@ class MpyTool():
         """Format progress/skip line: [2/5] 100% 24.1K source -> dest (base64)"""
         size_str = self.format_size(total)
         multi = self._progress_total_files > 1
-        prefix = f"[{self._progress_current_file}/{self._progress_total_files}]" if multi else ""
+        if multi:
+            width = len(str(self._progress_total_files))
+            prefix = f"[{self._progress_current_file:>{width}}/{self._progress_total_files}]"
+        else:
+            prefix = ""
         src_w = max(len(self._progress_src), self._progress_max_src_len)
         dst_w = max(len(self._progress_dst), self._progress_max_dst_len)
         enc = self._format_encoding_info(encodings, pad=multi) if encodings else (" " * self._ENC_WIDTH if multi else "")
@@ -167,7 +203,7 @@ class MpyTool():
         else:
             self._progress_src = self._format_local_path(src)
         if is_dst_remote:
-            self._progress_dst = ':' + dst
+            self._progress_dst = ':' + ('/' + dst if not dst.startswith('/') else dst)
         else:
             self._progress_dst = self._format_local_path(dst)
         if len(self._progress_dst) > self._progress_max_dst_len:
@@ -294,9 +330,6 @@ class MpyTool():
                     paths.extend(self._collect_remote_paths(src_path))
                 else:
                     paths.extend(self._collect_local_paths(src_path))
-        elif cmd == 'put' and len(commands) >= 2:
-            src_path = commands[1]
-            paths.extend(self._collect_local_paths(src_path))
         return paths
 
     def _collect_remote_paths(self, path):
@@ -348,15 +381,9 @@ class MpyTool():
                     # remote -> remote (file only)
                     stat = self._mpy.stat(src_path)
                     if stat is not None and stat >= 0:
-                        basename = src_path.split('/')[-1]
-                        dst_paths.append(':' + (dest_path + basename if dest_is_dir else dest_path))
+                        dst = _join_remote_path(dest_path, _remote_basename(src_path)) if dest_is_dir else dest_path
+                        dst_paths.append(':' + dst)
             return dst_paths
-        elif cmd == 'put' and len(commands) >= 2:
-            src_path = commands[1]
-            dst_path = commands[2] if len(commands) > 2 else '/'
-            if _os.path.exists(src_path):
-                files = self._collect_dst_files(src_path, dst_path.rstrip('/') or '/', add_src_basename=True)
-                return [':' + p for p in files]
         return []
 
     def _collect_remote_to_local_dst(self, src_path, dest_path, dest_is_dir, copy_contents):
@@ -366,10 +393,10 @@ class MpyTool():
             return []
         base_dst = dest_path.rstrip('/') or '.'
         if dest_is_dir and not copy_contents and src_path != '/':
-            base_dst = _os.path.join(base_dst, src_path.split('/')[-1])
+            base_dst = _os.path.join(base_dst, _remote_basename(src_path))
         if stat >= 0:  # file
             if _os.path.isdir(base_dst) or dest_is_dir:
-                return [self._format_local_path(_os.path.join(base_dst, src_path.split('/')[-1]))]
+                return [self._format_local_path(_os.path.join(base_dst, _remote_basename(src_path)))]
             return [self._format_local_path(base_dst)]
         return self._collect_remote_dir_dst(src_path, base_dst)
 
@@ -444,14 +471,6 @@ class MpyTool():
             file_info = f"{total_files} files"
         self.verbose(f"  {summary}  ({file_info})", color='green')
 
-    def cmd_ls(self, dir_name):
-        result = self._mpy.ls(dir_name)
-        for name, size in result:
-            if size is not None:
-                print(f'{self.format_size(size):>9} {name}')
-            else:
-                print(f'{"":9} {name}/')
-
     @classmethod
     def print_tree(cls, tree, prefix='', print_size=True, first=True, last=True):
         """Print tree of files
@@ -464,12 +483,14 @@ class MpyTool():
             else:
                 this_prefix = cls.TEE
         sufix = ''
-        if sub_tree is not None and name != ('/'):
+        if sub_tree is not None and name != '/':
             sufix = '/'
+        # For root, display './' only for empty path (CWD)
+        display_name = '.' if first and name in ('', '.') else name
         line = ''
         if print_size:
             line += f'{cls.format_size(size):>9} '
-        line += prefix + this_prefix + name + sufix
+        line += prefix + this_prefix + display_name + sufix
         print(line)
         if not sub_tree:
             return
@@ -493,16 +514,6 @@ class MpyTool():
             first=False,
             last=True)
 
-    def cmd_tree(self, dir_name):
-        tree = self._mpy.tree(dir_name)
-        self.print_tree(tree)
-
-    def cmd_get(self, *file_names):
-        for file_name in file_names:
-            self.verbose(f"GET: {file_name}", 2)
-            data = self._mpy.get(file_name)
-            print(data.decode('utf-8'))
-
     def _upload_file(self, data, src_path, dst_path, show_progress):
         """Upload file data to device with stats tracking and progress display"""
         file_size = len(data)
@@ -527,10 +538,21 @@ class MpyTool():
             self._stats_wire_bytes += wire
         return True  # uploaded
 
-    def _put_dir(self, src_path, dst_path, show_progress=True):
-        basename = _os.path.basename(_os.path.abspath(src_path))
+    def _put_dir(self, src_path, dst_path, show_progress=True, target_name=None):
+        """Upload directory to device
+
+        Arguments:
+            src_path: local source directory
+            dst_path: remote destination parent directory
+            show_progress: show progress bar
+            target_name: if set, use this as directory name instead of src basename
+        """
+        if target_name is not None:
+            basename = target_name
+        else:
+            basename = _os.path.basename(_os.path.abspath(src_path))
         if basename:
-            dst_path = _os.path.join(dst_path, basename)
+            dst_path = _join_remote_path(dst_path, basename)
         self.verbose(f"PUT DIR: {src_path} -> {dst_path}", 2)
         created_dirs = set()
         for path, dirs, files in _os.walk(src_path, topdown=True):
@@ -565,17 +587,6 @@ class MpyTool():
                 raise _mpytool.MpyError(f'Error creating file under file: {parent}')
         self._upload_file(data, src_path, dst_path, show_progress)
 
-    def cmd_put(self, src_path, dst_path):
-        if self._verbose >= 1 and not self._batch_mode:
-            self._progress_total_files = len(self._collect_local_paths(src_path))
-            self._progress_current_file = 0
-        if _os.path.isdir(src_path):
-            self._put_dir(src_path, dst_path)
-        elif _os.path.isfile(src_path):
-            self._put_file(src_path, dst_path)
-        else:
-            raise ParamsError(f'No file or directory to upload: {src_path}')
-
     def _get_file(self, src_path, dst_path, show_progress=True):
         """Download single file from device"""
         self.verbose(f"GET FILE: {src_path} -> {dst_path}", 2)
@@ -599,7 +610,7 @@ class MpyTool():
     def _get_dir(self, src_path, dst_path, copy_contents=False, show_progress=True):
         """Download directory from device"""
         if not copy_contents:
-            basename = src_path.rstrip('/').split('/')[-1]
+            basename = _remote_basename(src_path)
             if basename:
                 dst_path = _os.path.join(dst_path, basename)
         self.verbose(f"GET DIR: {src_path} -> {dst_path}", 2)
@@ -615,19 +626,28 @@ class MpyTool():
                 self._get_file(src_entry, dst_entry, show_progress=show_progress)
 
     def _cp_local_to_remote(self, src_path, dst_path, dst_is_dir):
-        """Upload local file/dir to device"""
-        src_is_dir = _os.path.isdir(src_path)
+        """Upload local file/dir to device
+
+        Path semantics:
+        - dst_is_dir=True: add source basename to dst_path (unless copy_contents)
+        - dst_is_dir=False: dst_path is the target name (rename)
+        - copy_contents (src ends with /): copy contents, not directory itself
+        """
+        src_is_dir = _os.path.isdir(src_path.rstrip('/'))
         copy_contents = src_path.endswith('/')
         src_path = src_path.rstrip('/')
         if not _os.path.exists(src_path):
             raise ParamsError(f'Source not found: {src_path}')
-        if dst_is_dir:
-            if not copy_contents:
-                basename = _os.path.basename(src_path)
-                dst_path = dst_path + basename
+        # Normalize dst_path (remove trailing slash, but keep '/' for root)
+        if dst_path == '/':
+            pass  # Keep '/' as is
+        elif dst_path:
             dst_path = dst_path.rstrip('/')
+        else:
+            dst_path = ''
         if src_is_dir:
             if copy_contents:
+                # Copy directory contents to dst_path
                 for item in _os.listdir(src_path):
                     if self._is_excluded(item):
                         continue
@@ -635,10 +655,19 @@ class MpyTool():
                     if _os.path.isdir(item_src):
                         self._put_dir(item_src, dst_path)
                     else:
-                        self._put_file(item_src, dst_path + '/')
+                        self._put_file(item_src, _join_remote_path(dst_path, item))
+            elif dst_is_dir:
+                # Copy directory to destination directory (_put_dir adds basename)
+                self._put_dir(src_path, dst_path)
             else:
-                self._put_dir(src_path, _os.path.dirname(dst_path) or '/')
+                # Rename: copy directory with new name
+                parent = _os.path.dirname(dst_path)
+                target_name = _os.path.basename(dst_path)
+                self._put_dir(src_path, parent, target_name=target_name)
         else:
+            # File: add basename if dst_is_dir
+            if dst_is_dir:
+                dst_path = _join_remote_path(dst_path, _os.path.basename(src_path))
             self._put_file(src_path, dst_path)
 
     def _cp_remote_to_local(self, src_path, dst_path, dst_is_dir):
@@ -653,14 +682,12 @@ class MpyTool():
             if not _os.path.exists(dst_path):
                 _os.makedirs(dst_path)
             if not copy_contents and src_path != '/':
-                basename = src_path.split('/')[-1]
-                dst_path = _os.path.join(dst_path, basename)
+                dst_path = _os.path.join(dst_path, _remote_basename(src_path))
         if src_is_dir:
             self._get_dir(src_path, dst_path, copy_contents=copy_contents)
         else:
             if _os.path.isdir(dst_path):
-                basename = src_path.split('/')[-1]
-                dst_path = _os.path.join(dst_path, basename)
+                dst_path = _os.path.join(dst_path, _remote_basename(src_path))
             self._get_file(src_path, dst_path)
 
     def _cp_remote_to_remote(self, src_path, dst_path, dst_is_dir):
@@ -672,8 +699,7 @@ class MpyTool():
         if stat == -1:
             raise ParamsError('Remote-to-remote directory copy not supported yet')
         if dst_is_dir:
-            basename = src_path.split('/')[-1]
-            dst_path = dst_path + basename
+            dst_path = _join_remote_path(dst_path, _remote_basename(src_path))
         self.verbose(f"COPY: {src_path} -> {dst_path}", 2)
         if self._verbose >= 1:
             self._progress_current_file += 1
@@ -740,11 +766,18 @@ class MpyTool():
         dest = args[-1]
         dest_is_remote = dest.startswith(':')
         dest_path = dest[1:] if dest_is_remote else dest
-        if not dest_path:
-            dest_path = '/'
-        dest_is_dir = dest_path.endswith('/')
-        if len(sources) > 1 and not dest_is_dir:
-            raise ParamsError('multiple sources require destination directory (ending with /)')
+        # Determine if destination is a directory:
+        # - Remote: '' (CWD) or '/' (root) or ends with '/'
+        # - Local: ends with '/' or exists as directory
+        if dest_is_remote:
+            dest_is_dir = dest_path == '' or dest_path == '/' or dest_path.endswith('/')
+        else:
+            dest_is_dir = dest_path.endswith('/') or _os.path.isdir(dest_path)
+        # Check if any source copies contents (trailing slash) or multiple sources
+        has_multi_source = len(sources) > 1
+        has_contents_copy = any(s.rstrip('/') != s for s in sources)  # any source has trailing /
+        if (has_multi_source or has_contents_copy) and not dest_is_dir:
+            raise ParamsError('multiple sources or directory contents require destination directory (ending with /)')
         if self._verbose >= 1 and not self._batch_mode:
             total_files = 0
             for src in sources:
@@ -766,8 +799,9 @@ class MpyTool():
                     copy_contents = src.endswith('/')
                     src_path = src.rstrip('/')
                     if _os.path.exists(src_path):
-                        add_basename = not copy_contents
-                        all_dst_files.update(self._collect_dst_files(src_path, dest_path.rstrip('/') or '/', add_basename))
+                        add_basename = dest_is_dir and not copy_contents
+                        base_path = dest_path.rstrip('/') if dest_path else ''
+                        all_dst_files.update(self._collect_dst_files(src_path, base_path, add_basename))
             if all_dst_files and not self._batch_mode:
                 self._progress_max_dst_len = max(len(':' + p) for p in all_dst_files)
                 if not self._force:
@@ -792,50 +826,51 @@ class MpyTool():
             raise ParamsError('mv requires source and destination')
         sources = list(args[:-1])
         dest = args[-1]
-        if not dest.startswith(':'):
-            raise ParamsError('mv destination must be device path (: prefix)')
+        dest_path = _parse_device_path(dest, 'mv destination')
         for src in sources:
-            if not src.startswith(':'):
-                raise ParamsError('mv source must be device path (: prefix)')
-        dest_path = dest[1:] or '/'
-        dest_is_dir = dest_path.endswith('/')
+            _parse_device_path(src, 'mv source')  # validate only
+        # ':' = CWD (empty string), ':/' = root
+        dest_is_dir = dest_path == '' or dest_path == '/' or dest_path.endswith('/')
         if len(sources) > 1 and not dest_is_dir:
             raise ParamsError('multiple sources require destination directory (ending with /)')
         self._mpy.import_module('os')
         for src in sources:
-            src_path = src[1:]
+            src_path = _parse_device_path(src, 'mv')
             stat = self._mpy.stat(src_path)
             if stat is None:
                 raise ParamsError(f'Source not found on device: {src_path}')
             if dest_is_dir:
-                dst_dir = dest_path.rstrip('/')
-                if dst_dir and self._mpy.stat(dst_dir) is None:
+                # Preserve '/' as root, strip trailing slash from others
+                dst_dir = '/' if dest_path == '/' else dest_path.rstrip('/')
+                if dst_dir and dst_dir != '/' and self._mpy.stat(dst_dir) is None:
                     self._mpy.mkdir(dst_dir)
-                basename = src_path.rstrip('/').split('/')[-1]
-                final_dest = dest_path + basename
+                final_dest = _join_remote_path(dst_dir, _remote_basename(src_path))
             else:
                 final_dest = dest_path
             self.verbose(f"MV: {src_path} -> {final_dest}", 1)
             self._mpy.rename(src_path, final_dest)
 
-    def cmd_mkdir(self, *dir_names):
-        for dir_name in dir_names:
-            self.verbose(f"MKDIR: {dir_name}", 1)
-            self._mpy.mkdir(dir_name)
-
-    def cmd_delete(self, *file_names):
+    def cmd_rm(self, *file_names):
+        """Delete files/directories on device"""
         for file_name in file_names:
-            contents_only = file_name.endswith('/')
-            path = file_name.rstrip('/') or '/'
+            raw_path = _parse_device_path(file_name, 'rm')
+            contents_only = raw_path.endswith('/') or raw_path == ''
+            # ':' = CWD contents, ':/' = root, ':/path' = path, ':path/' = path contents
+            if raw_path == '':
+                path = ''  # CWD
+            elif raw_path == '/':
+                path = '/'  # root
+            else:
+                path = raw_path.rstrip('/') if contents_only else raw_path
             if contents_only:
-                self.verbose(f"DELETE contents: {path}", 1)
+                self.verbose(f"RM contents: {path or 'CWD'}", 1)
                 entries = self._mpy.ls(path)
                 for name, size in entries:
-                    entry_path = path + '/' + name if path != '/' else '/' + name
+                    entry_path = _join_remote_path(path, name)
                     self.verbose(f"  {entry_path}", 1)
                     self._mpy.delete(entry_path)
             else:
-                self.verbose(f"DELETE: {path}", 1)
+                self.verbose(f"RM: {path}", 1)
                 self._mpy.delete(path)
 
     def cmd_monitor(self):
@@ -861,12 +896,6 @@ class MpyTool():
         terminal.run()
         self._log.info('Exiting..')
 
-    def cmd_exec(self, code):
-        self.verbose(f"EXEC: {code}", 1)
-        result = self._mpy.comm.exec(code)
-        if result:
-            print(result.decode('utf-8', 'backslashreplace'), end='')
-
     @staticmethod
     def format_size(size):
         """Format size in bytes to human readable format (like ls -h)"""
@@ -882,28 +911,6 @@ class MpyTool():
                 return f"{size:.0f}{unit}"
         return f"{size:.0f}T"
 
-    def cmd_paths(self, dir_name='.'):
-        """Print all paths (for shell completion) - undocumented"""
-        tree = self._mpy.tree(dir_name)
-        self._print_paths(tree, '')
-
-    def _print_paths(self, entry, prefix):
-        """Recursively print paths from tree structure"""
-        name, size, children = entry
-        if name in ('.', './'):
-            path = ''
-        else:
-            path = prefix + name
-        if children is None:
-            # File
-            print(path)
-        else:
-            # Directory
-            if path:
-                print(path + '/')
-            for child in children:
-                self._print_paths(child, path + '/' if path else '')
-
     def cmd_ota(self, firmware_path):
         """OTA firmware update from local .app-bin file"""
         self.verbose("OTA UPDATE", 1)
@@ -1095,213 +1102,272 @@ class MpyTool():
             fs_pct = (fs['used'] / fs['total'] * 100) if fs['total'] > 0 else 0
             print(f"{label:12} {self.format_size(fs['used'])} / {self.format_size(fs['total'])} ({fs_pct:.2f}%)")
 
-    def cmd_mreset(self, reconnect=True):
-        """MCU reset using machine.reset() with optional auto-reconnect"""
-        self.verbose("MRESET", 1)
-        if reconnect:
+    def cmd_reset(self, mode='soft', reconnect=True, timeout=None):
+        """Reset device in specified mode
+
+        Modes:
+            soft     - Ctrl-D soft reset, runs boot.py/main.py (default)
+            raw      - soft reset in raw REPL, clears RAM only
+            machine  - machine.reset() with optional reconnect
+            rts      - hardware reset via DTR/RTS with optional reconnect
+            boot     - enter bootloader via machine.bootloader()
+            dtr-boot - enter bootloader via DTR/RTS signals (ESP32)
+        """
+        self.verbose(f"RESET {mode}", 1)
+        if mode == 'soft':
+            self._mpy.soft_reset()
+        elif mode == 'raw':
+            self._mpy.soft_reset_raw()
+        elif mode == 'machine':
+            if reconnect:
+                try:
+                    self.verbose("  reconnecting...", 1, color='yellow')
+                    self._mpy.machine_reset(
+                        reconnect=True, timeout=timeout)
+                    self.verbose("  connected", 1, color='green')
+                except (_mpytool.ConnError, OSError) as err:
+                    self.verbose(
+                        f"  reconnect failed: {err}", 1, color='red')
+                    raise _mpytool.ConnError(
+                        f"Reconnect failed: {err}")
+            else:
+                self._mpy.machine_reset(reconnect=False)
+        elif mode == 'rts':
             try:
-                self.verbose("  reconnecting...", 1, color='yellow')
-                self._mpy.machine_reset(reconnect=True)
-                self.verbose("  connected", 1, color='green')
+                self._mpy.hard_reset()
+                if reconnect:
+                    self.verbose(
+                        "  reconnecting...", 1, color='yellow')
+                    _time.sleep(1.0)  # Wait for device to boot
+                    self._mpy._conn.reconnect()
+                    self.verbose("  connected", 1, color='green')
+            except NotImplementedError:
+                raise _mpytool.MpyError(
+                    "Hardware reset not available (serial only)")
             except (_mpytool.ConnError, OSError) as err:
-                self.verbose(f"  reconnect failed: {err}", 1, color='red')
-                raise _mpytool.ConnError(f"Reconnect failed: {err}")
+                self.verbose(
+                    f"  reconnect failed: {err}", 1, color='red')
+                raise _mpytool.ConnError(
+                    f"Reconnect failed: {err}")
+        elif mode == 'boot':
+            self._mpy.machine_bootloader()
+        elif mode == 'dtr-boot':
+            try:
+                self._mpy.reset_to_bootloader()
+            except NotImplementedError:
+                raise _mpytool.MpyError(
+                    "DTR boot not available (serial only)")
+
+    # -- dispatch methods for process_commands() --
+
+    def _dispatch_ls(self, commands, is_last_group):
+        dir_name = ':'
+        if commands:
+            dir_name = commands.pop(0)
+            # Strip trailing / except for root
+            if dir_name not in (':', ':/'):
+                dir_name = dir_name.rstrip('/')
+        path = _parse_device_path(dir_name, 'ls')
+        result = self._mpy.ls(path)
+        for name, size in result:
+            if size is not None:
+                print(f'{self.format_size(size):>9} {name}')
+            else:
+                print(f'{"":9} {name}/')
+
+    def _dispatch_tree(self, commands, is_last_group):
+        dir_name = ':'
+        if commands:
+            dir_name = commands.pop(0)
+            if dir_name not in (':', ':/'):
+                dir_name = dir_name.rstrip('/')
+        path = _parse_device_path(dir_name, 'tree')
+        tree = self._mpy.tree(path)
+        self.print_tree(tree)
+
+    def _dispatch_cat(self, commands, is_last_group):
+        if not commands:
+            raise ParamsError('missing file name for cat command')
+        for file_name in commands:
+            path = _parse_device_path(file_name, 'cat')
+            self.verbose(f"CAT: {path}", 2)
+            data = self._mpy.get(path)
+            print(data.decode('utf-8'))
+        commands.clear()
+
+    def _dispatch_mkdir(self, commands, is_last_group):
+        if not commands:
+            raise ParamsError('missing directory name for mkdir command')
+        for dir_name in commands:
+            path = _parse_device_path(dir_name, 'mkdir')
+            self.verbose(f"MKDIR: {path}", 1)
+            self._mpy.mkdir(path)
+        commands.clear()
+
+    def _dispatch_rm(self, commands, is_last_group):
+        if not commands:
+            raise ParamsError('missing file name for rm command')
+        self.cmd_rm(*commands)
+        commands.clear()
+
+    def _dispatch_pwd(self, commands, is_last_group):
+        cwd = self._mpy.getcwd()
+        print(cwd)
+
+    def _dispatch_cd(self, commands, is_last_group):
+        if not commands:
+            raise ParamsError('missing directory for cd command')
+        dir_name = commands.pop(0)
+        path = _parse_device_path(dir_name, 'cd')
+        self.verbose(f"CD: {path}", 2)
+        self._mpy.chdir(path)
+
+    def _dispatch_reset(self, commands, is_last_group):
+        mode = 'soft'
+        timeout = None
+        _reset_modes = (
+            '--machine', '--rts', '--raw',
+            '--boot', '--dtr-boot')
+        while commands and commands[0].startswith('-'):
+            flag = commands[0]
+            if flag in _reset_modes:
+                mode = commands.pop(0)[2:]  # strip --
+            elif flag in ('-t', '--timeout'):
+                commands.pop(0)
+                if commands:
+                    timeout = int(commands.pop(0))
+                else:
+                    raise ParamsError(
+                        'missing value for --timeout')
+            else:
+                raise ParamsError(
+                    f"unknown reset flag: '{flag}'")
+        if timeout and mode not in ('machine', 'rts'):
+            raise ParamsError(
+                '--timeout only with --machine or --rts')
+        has_more = bool(commands) or not is_last_group
+        reconnect = has_more if mode in (
+            'machine', 'rts') else True
+        self.cmd_reset(
+            mode=mode, reconnect=reconnect,
+            timeout=timeout)
+
+    def _dispatch_monitor(self, commands, is_last_group):
+        self.cmd_monitor()
+        commands.clear()
+
+    def _dispatch_repl(self, commands, is_last_group):
+        self.cmd_repl()
+        commands.clear()
+
+    def _dispatch_exec(self, commands, is_last_group):
+        if not commands:
+            raise ParamsError('missing code for exec command')
+        code = commands.pop(0)
+        self.verbose(f"EXEC: {code}", 1)
+        result = self._mpy.comm.exec(code)
+        if result:
+            print(result.decode('utf-8', 'backslashreplace'), end='')
+
+    def _dispatch_info(self, commands, is_last_group):
+        self.cmd_info()
+
+    def _dispatch_flash(self, commands, is_last_group):
+        if commands and commands[0] == 'read':
+            commands.pop(0)
+            if len(commands) >= 2:
+                # ESP32: flash read <label> <file>
+                label = commands.pop(0)
+                dest_path = commands.pop(0)
+                self.cmd_flash_read(dest_path, label=label)
+            elif len(commands) == 1:
+                # RP2: flash read <file>
+                dest_path = commands.pop(0)
+                self.cmd_flash_read(dest_path)
+            else:
+                raise ParamsError('flash read requires destination file')
+        elif commands and commands[0] == 'write':
+            commands.pop(0)
+            if len(commands) >= 2:
+                # ESP32: flash write <label> <file>
+                label = commands.pop(0)
+                src_path = commands.pop(0)
+                self.cmd_flash_write(src_path, label=label)
+            elif len(commands) == 1:
+                # RP2: flash write <file>
+                src_path = commands.pop(0)
+                self.cmd_flash_write(src_path)
+            else:
+                raise ParamsError('flash write requires source file')
+        elif commands and commands[0] == 'erase':
+            commands.pop(0)
+            full = False
+            label = None
+            while commands and (commands[0] == '--full' or not commands[0].startswith('-')):
+                if commands[0] == '--full':
+                    full = True
+                    commands.pop(0)
+                elif label is None:
+                    label = commands.pop(0)
+                else:
+                    break
+            self.cmd_flash_erase(label=label, full=full)
         else:
-            self._mpy.machine_reset(reconnect=False)
+            self.cmd_flash()
 
-    def cmd_sreset(self):
-        """Soft reset in raw REPL - clears RAM but doesn't run boot.py/main.py"""
-        self.verbose("SRESET", 1)
-        self._mpy.soft_reset_raw()
+    def _dispatch_ota(self, commands, is_last_group):
+        if not commands:
+            raise ParamsError('ota requires firmware file path')
+        self.cmd_ota(commands.pop(0))
 
-    def cmd_rtsreset(self, reconnect=True):
-        """Hardware reset device using RTS signal with optional auto-reconnect"""
-        self.verbose("RTSRESET", 1)
+    def _dispatch_sleep(self, commands, is_last_group):
+        if not commands:
+            raise ParamsError('sleep requires a number (seconds)')
         try:
-            self._mpy.hard_reset()
-            if reconnect:
-                self.verbose("  reconnecting...", 1, color='yellow')
-                _time.sleep(1.0)  # Wait for device to boot
-                self._mpy._conn.reconnect()
-                self.verbose("  connected", 1, color='green')
-        except NotImplementedError:
-            raise _mpytool.MpyError("Hardware reset not available (serial only)")
-        except (_mpytool.ConnError, OSError) as err:
-            self.verbose(f"  reconnect failed: {err}", 1, color='red')
-            raise _mpytool.ConnError(f"Reconnect failed: {err}")
+            seconds = float(commands.pop(0))
+        except ValueError:
+            raise ParamsError('sleep requires a number (seconds)')
+        self.verbose(f"SLEEP {seconds}s", 1)
+        _time.sleep(seconds)
 
-    def cmd_bootloader(self):
-        """Enter bootloader using machine.bootloader()"""
-        self.verbose("BOOTLOADER", 1)
-        self._mpy.machine_bootloader()
+    def _dispatch_cp(self, commands, is_last_group):
+        if len(commands) < 2:
+            raise ParamsError('cp requires source and destination')
+        self.cmd_cp(*commands)
+        commands.clear()
 
-    def cmd_dtrboot(self):
-        """Enter bootloader using DTR/RTS signals (ESP32 only)
+    def _dispatch_mv(self, commands, is_last_group):
+        if len(commands) < 2:
+            raise ParamsError('mv requires source and destination')
+        self.cmd_mv(*commands)
+        commands.clear()
 
-        Auto-detects port type:
-        - USB-UART: classic DTR/RTS sequence (GPIO0 directly connected)
-        - USB-CDC: USB-JTAG-Serial sequence (ESP32-S/C native USB)
-        """
-        self.verbose("DTRBOOT", 1)
+    def _dispatch_paths(self, commands, is_last_group):
+        # For shell completion
+        dir_name = commands.pop(0) if commands else ':'
+        path = _parse_device_path(dir_name, '_paths')
         try:
-            self._mpy.reset_to_bootloader()
-        except NotImplementedError:
-            raise _mpytool.MpyError("DTR boot not available (serial only)")
+            entries = self._mpy.ls(path)
+        except (_mpytool.DirNotFound, _mpytool.MpyError):
+            return
+        for name, size in entries:
+            print(name + '/' if size is None else name)
 
-    def cmd_sleep(self, seconds):
-        """Sleep for specified number of seconds"""
-        self.verbose(f"SLEEP {seconds}s", 1)
-        _time.sleep(seconds)
+    # -- command dispatching --
+
+    _COMMANDS = frozenset({
+        'ls', 'tree', 'cat', 'mkdir', 'rm', 'pwd', 'cd',
+        'reset', 'monitor', 'repl', 'exec', 'info', 'flash',
+        'ota', 'sleep', 'cp', 'mv', '_paths',
+    })
 
     def process_commands(self, commands, is_last_group=False):
-        try:
-            while commands:
-                command = commands.pop(0)
-                if command in ('ls', 'dir'):
-                    if commands:
-                        dir_name = commands.pop(0)
-                        if dir_name != '/':
-                            dir_name = dir_name.rstrip('/')
-                        self.cmd_ls(dir_name)
-                        continue
-                    self.cmd_ls('.')
-                elif command == 'tree':
-                    if commands:
-                        dir_name = commands.pop(0)
-                        if dir_name != '/':
-                            dir_name = dir_name.rstrip('/')
-                        self.cmd_tree(dir_name)
-                        continue
-                    self.cmd_tree('.')
-                elif command in ('get', 'cat'):
-                    if commands:
-                        self.cmd_get(*commands)
-                        break
-                    raise ParamsError('missing file name for get command')
-                elif command == 'put':
-                    if commands:
-                        src_path = commands.pop(0)
-                        dst_path = ''
-                        if commands:
-                            dst_path = commands.pop(0)
-                        self.cmd_put(src_path, dst_path)
-                    else:
-                        raise ParamsError('missing file name for put command')
-                elif command == 'mkdir':
-                    self.cmd_mkdir(*commands)
-                    break
-                elif command in ('del', 'delete', 'rm'):
-                    self.cmd_delete(*commands)
-                    break
-                elif command == 'reset':
-                    self.verbose("RESET", 1)
-                    self._mpy.soft_reset()
-                elif command == 'mreset':
-                    # Reconnect only if there are more commands (in this or next group)
-                    has_more = bool(commands) or not is_last_group
-                    self.cmd_mreset(reconnect=has_more)
-                elif command == 'sreset':
-                    self.cmd_sreset()
-                elif command in ('monitor', 'follow'):
-                    self.cmd_monitor()
-                    break
-                elif command == 'repl':
-                    self.cmd_repl()
-                    break
-                elif command == 'exec':
-                    if commands:
-                        code = commands.pop(0)
-                        self.cmd_exec(code)
-                    else:
-                        raise ParamsError('missing code for exec command')
-                elif command == 'info':
-                    self.cmd_info()
-                elif command == 'flash':
-                    if commands and commands[0] == 'read':
-                        commands.pop(0)
-                        if len(commands) >= 2:
-                            # ESP32: flash read <label> <file>
-                            label = commands.pop(0)
-                            dest_path = commands.pop(0)
-                            self.cmd_flash_read(dest_path, label=label)
-                        elif len(commands) == 1:
-                            # RP2: flash read <file>
-                            dest_path = commands.pop(0)
-                            self.cmd_flash_read(dest_path)
-                        else:
-                            raise ParamsError('flash read requires destination file')
-                    elif commands and commands[0] == 'write':
-                        commands.pop(0)
-                        if len(commands) >= 2:
-                            # ESP32: flash write <label> <file>
-                            label = commands.pop(0)
-                            src_path = commands.pop(0)
-                            self.cmd_flash_write(src_path, label=label)
-                        elif len(commands) == 1:
-                            # RP2: flash write <file>
-                            src_path = commands.pop(0)
-                            self.cmd_flash_write(src_path)
-                        else:
-                            raise ParamsError('flash write requires source file')
-                    elif commands and commands[0] == 'erase':
-                        commands.pop(0)
-                        # Check for --full flag and optional label
-                        full = False
-                        label = None
-                        while commands and (commands[0] == '--full' or not commands[0].startswith('-')):
-                            if commands[0] == '--full':
-                                full = True
-                                commands.pop(0)
-                            elif label is None:
-                                label = commands.pop(0)
-                            else:
-                                break
-                        self.cmd_flash_erase(label=label, full=full)
-                    else:
-                        self.cmd_flash()
-                elif command == 'ota':
-                    if commands:
-                        firmware_path = commands.pop(0)
-                        self.cmd_ota(firmware_path)
-                    else:
-                        raise ParamsError('ota requires firmware file path')
-                elif command == 'rtsreset':
-                    # Reconnect only if there are more commands (in this or next group)
-                    has_more = bool(commands) or not is_last_group
-                    self.cmd_rtsreset(reconnect=has_more)
-                elif command == 'bootloader':
-                    self.cmd_bootloader()
-                elif command == 'dtrboot':
-                    self.cmd_dtrboot()
-                elif command == 'sleep':
-                    if commands:
-                        try:
-                            seconds = float(commands.pop(0))
-                        except ValueError:
-                            raise ParamsError('sleep requires a number (seconds)')
-                        self.cmd_sleep(seconds)
-                    else:
-                        raise ParamsError('sleep requires a number (seconds)')
-                elif command == 'cp':
-                    if len(commands) >= 2:
-                        self.cmd_cp(*commands)
-                        break
-                    raise ParamsError('cp requires source and destination')
-                elif command == 'mv':
-                    if len(commands) >= 2:
-                        self.cmd_mv(*commands)
-                        break
-                    raise ParamsError('mv requires source and destination')
-                elif command == '_paths':
-                    # Undocumented: for shell completion
-                    if commands:
-                        self.cmd_paths(commands.pop(0))
-                    else:
-                        self.cmd_paths()
-                else:
-                    raise ParamsError(f"unknown command: '{command}'")
-        except (_mpytool.MpyError, _mpytool.ConnError) as err:
-            self._log.error(err)
+        while commands:
+            command = commands.pop(0)
+            if command not in self._COMMANDS:
+                raise ParamsError(f"unknown command: '{command}'")
+            dispatch = getattr(self, f'_dispatch_{command.lstrip("_")}')
+            dispatch(commands, is_last_group)
         try:
             self._mpy.comm.exit_raw_repl()
         except _mpytool.ConnError:
@@ -1313,38 +1379,34 @@ if _about:
 else:
     _VERSION_STR = "mpytool (not installed version)"
 _COMMANDS_HELP_STR = """
-List of available commands:
-  ls [{path}]                   list files and its sizes
-  tree [{path}]                 list tree of structure and sizes
-  cp [-f] {src} [...] {dst}     copy files (: prefix = device path, -f = force)
-  mv {src} [...] {dst}          move/rename on device (: prefix required)
-  get {path} [...]              get file and print it
-  put {src_path} [{dst_path}]   put file or directory to destination
-  mkdir {path} [...]            create directory (also create all parents)
-  delete {path} [...]           remove file/dir (path/ = contents only)
-  reset                         soft reset (Ctrl-D, runs boot.py/main.py)
-  sreset                        soft reset in raw REPL (clears RAM only)
-  mreset                        MCU reset (machine.reset, auto-reconnect)
-  rtsreset                      RTS reset (hardware reset via RTS signal)
-  bootloader                    enter bootloader (machine.bootloader)
-  dtrboot                       enter bootloader via DTR/RTS (ESP32 only)
-  monitor                       print output of running program
-  repl                          enter REPL mode [UNIX OS ONLY]
-  exec {code}                   execute Python code on device
+Commands (: prefix = device path, :/ = root, : = CWD):
+  ls [:path]                    list files and sizes (default: CWD)
+  tree [:path]                  list directory tree (default: CWD)
+  cat {:path} [...]             print file content to stdout
+  cp [-f] {src} [...] {dst}     copy files (-f = force overwrite)
+  mv {:src} [...] {:dst}        move/rename on device
+  mkdir {:path} [...]           create directory (with parents)
+  rm {:path} [...]              delete file/dir (:path/ = contents only)
+  pwd                           print current working directory
+  cd {:path}                    change current working directory
+  reset [flags]                  soft reset (Ctrl-D) by default
+    --machine [-t {s}]            machine.reset() with reconnect
+    --rts [-t {s}]                hardware reset via DTR/RTS signal
+    --raw                         soft reset in raw REPL
+    --boot                        enter bootloader (machine.bootloader)
+    --dtr-boot                    bootloader via DTR/RTS (ESP32)
+  monitor                       print device output (Ctrl+C to stop)
+  repl                          interactive REPL [Unix only]
+  exec {code}                   execute Python code
   info                          show device information
-  flash                         show flash info (RP2) or partitions (ESP32)
+  flash                         show flash/partitions info
   flash read [{label}] {file}   read flash/partition to file
   flash write [{label}] {file}  write file to flash/partition
   flash erase [{label}] [--full]  erase flash/partition
-  ota {firmware.app-bin}        OTA firmware update (ESP32 only)
-  sleep {seconds}               sleep for specified seconds
-Aliases:
-  dir                           alias to ls
-  cat                           alias to get
-  del, rm                       alias to delete
-  follow                        alias to monitor
-Use -- to separate multiple commands:
-  mpytool put main.py / -- reset -- monitor
+  ota {firmware.app-bin}        OTA update (ESP32)
+  sleep {seconds}               pause between commands
+Use -- to chain commands:
+  mpytool cp main.py : -- reset -- monitor
 """
 
 
@@ -1488,11 +1550,11 @@ def main():
     command_groups = _utils.split_commands(args.commands)
     try:
         _run_commands(mpy_tool, command_groups, with_progress=(args.verbose >= 1))
+    except (_mpytool.MpyError, _mpytool.ConnError, _mpytool.Timeout) as err:
+        log.error(err)
     except KeyboardInterrupt:
         # Clear partial progress line and show clean message
         log.verbose('Interrupted', level=0, overwrite=True)
-    except (_mpytool.MpyError, _mpytool.ConnError, _mpytool.Timeout) as err:
-        log.error(err)
 
 
 if __name__ == '__main__':

mpytool/utils.py

@@ -15,12 +15,11 @@ def parse_remote_path(path: str) -> str:
         path: path with : prefix
 
     Returns:
-        path without : prefix, or '/' if path is just ':'
+        path without : prefix (empty string for ':' means CWD)
     """
     if not is_remote_path(path):
         raise ValueError(f"Not a remote path: {path}")
-    result = path[1:]
-    return result if result else "/"
+    return path[1:]
 
 
 def split_commands(args: list[str], separator: str = "--") -> list[list[str]]:

{mpytool-2.1.0.dist-info → mpytool-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpytool
-Version: 2.1.0
+Version: 2.2.0
 Summary: MPY tool - manage files on devices running MicroPython
 Author-email: Pavel Revak <pavel.revak@gmail.com>
 License-Expression: MIT
@@ -83,27 +83,29 @@ $ mpytool --help
 
 list files:
 ```
-$ mpytool -p /dev/ttyACM0 ls
-$ mpytool -p /dev/ttyACM0 ls lib
+$ mpytool -p /dev/ttyACM0 ls         # list CWD (default)
+$ mpytool -p /dev/ttyACM0 ls :/lib   # list /lib
 ```
 
-tree files:
+tree:
 ```
-$ mpytool -p /dev/ttyACM0 tree
+$ mpytool -p /dev/ttyACM0 tree       # tree of CWD (default)
 ```
 
 copy files (: prefix = device path):
 ```
 $ mpytool cp main.py :/             # upload file to device root
 $ mpytool cp main.py lib.py :/lib/  # upload multiple files to directory
-$ mpytool cp myapp/ :/              # upload directory (creates /myapp/)
-$ mpytool cp myapp/ :/lib/          # upload directory into /lib/
+$ mpytool cp myapp :/               # upload directory (creates :/myapp/)
+$ mpytool cp myapp :/lib/           # upload directory into :/lib/ (creates :/lib/myapp/)
+$ mpytool cp myapp/ :/lib/          # upload directory contents into :/lib/
 $ mpytool cp :/main.py ./           # download file to current directory
 $ mpytool cp :/ ./backup/           # download entire device to backup/
 $ mpytool cp :/old.py :/new.py      # copy file on device
 $ mpytool cp -f main.py :/          # force upload even if unchanged
 ```
 
+Path semantics: `:` = device CWD, `:/` = device root. Trailing `/` on source = copy contents only.
 Unchanged files are automatically skipped (compares size and SHA256 hash).
 Use `-f` or `--force` to upload all files regardless.
 
@@ -124,29 +126,43 @@ $ mpytool mv :/file.py :/lib/       # move file to directory
 $ mpytool mv :/a.py :/b.py :/lib/   # move multiple files to directory
 ```
 
-legacy upload/download (still available):
+view file contents:
 ```
-$ mpytool put boot.py /
-$ mpytool get boot.py >> boot.py
+$ mpytool cat :boot.py            # print file from CWD
+$ mpytool cat :/lib/module.py     # print file with absolute path
 ```
 
-make directory, delete files:
+make directory, delete files (: prefix = device path):
 ```
-$ mpytool mkdir a/b/c/d xyz/abc   # create directories
-$ mpytool rm mydir                # delete directory and contents
-$ mpytool rm mydir/               # delete contents only, keep directory
-$ mpytool rm /                    # delete everything on device
+$ mpytool mkdir :lib :data        # create directories in CWD
+$ mpytool mkdir :/lib/subdir      # create with absolute path
+$ mpytool rm :old.py              # delete file in CWD
+$ mpytool rm :mydir               # delete directory and contents
+$ mpytool rm :mydir/              # delete contents only, keep directory
+$ mpytool rm :                    # delete everything in CWD
+$ mpytool rm :/                   # delete everything on device (root)
+```
+
+current working directory:
+```
+$ mpytool pwd                     # print current directory
+/
+$ mpytool cd :/lib                # change to /lib
+$ mpytool cd :subdir              # change to relative path (from CWD)
+$ mpytool cd :..                  # change to parent directory
+$ mpytool cd :/lib -- ls          # change directory and list files
 ```
 
 reset and REPL:
 ```
 $ mpytool reset              # soft reset (Ctrl-D, runs boot.py/main.py)
-$ mpytool sreset             # soft reset in raw REPL (clears RAM only)
-$ mpytool mreset             # MCU reset (machine.reset, auto-reconnect)
-$ mpytool rtsreset           # hardware reset via RTS signal (serial only)
-$ mpytool bootloader         # enter bootloader (machine.bootloader)
-$ mpytool dtrboot            # enter bootloader via DTR/RTS (ESP32 only)
-$ mpytool reset monitor      # reset and monitor output
+$ mpytool reset --raw        # soft reset in raw REPL (clears RAM only)
+$ mpytool reset --machine    # MCU reset (machine.reset, auto-reconnect)
+$ mpytool reset --machine -t 30  # MCU reset with 30s reconnect timeout
+$ mpytool reset --rts        # hardware reset via RTS signal (serial only)
+$ mpytool reset --boot       # enter bootloader (machine.bootloader)
+$ mpytool reset --dtr-boot   # enter bootloader via DTR/RTS (ESP32 only)
+$ mpytool reset -- monitor   # reset and monitor output
 $ mpytool repl               # enter REPL mode
 $ mpytool sleep 2            # sleep for 2 seconds (useful between commands)
 ```
@@ -214,13 +230,14 @@ $ mpytool flash erase vfs --full           # full erase partition
 OTA firmware update (ESP32):
 ```
 $ mpytool ota firmware.app-bin                    # flash to next OTA partition
-$ mpytool ota firmware.app-bin -- mreset          # flash and reboot
+$ mpytool ota firmware.app-bin -- reset --machine          # flash and reboot
+$ mpytool ota firmware.app-bin -- reset --machine -t 30    # flash and reboot with 30s timeout
 ```
 
 multiple commands separated by `--`:
 ```
-$ mpytool cp main.py boot.py :/ -- reset -- monitor
-$ mpytool delete old.py -- cp new.py :/ -- reset
+$ mpytool cp main.py boot.py : -- reset -- monitor
+$ mpytool rm :old.py -- cp new.py : -- reset
 ```
 
 auto-detect serial port (if only one device is connected):
@@ -265,12 +282,6 @@ show version:
 $ mpytool -V
 ```
 
-Command aliases:
-- `dir` = `ls`
-- `cat` = `get`
-- `del`, `rm` = `delete`
-- `follow` = `monitor`
-
 ## Python API
 
 ```python

mpytool-2.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+mpytool/__init__.py,sha256=4BRbfLRLpReWcDDbUA1A2UO1B8sNa6O5lgXRObbnP20,266
+mpytool/conn.py,sha256=3WvSyeHY2qv5YT9qEEPqhSGj68wIJOXqz6G2bPCL_OM,4331
+mpytool/conn_serial.py,sha256=AME-ry8dpBtkrkL5gp-aVxaO2Ddq5S6CmoLC5aIC7zI,4430
+mpytool/conn_socket.py,sha256=EZh6KGMwPgNoNgl0wK4l47N9KVtaSLd3DeCTIiZ4bRw,1531
+mpytool/logger.py,sha256=e9xaDf52nsMXU4T4Kv_pogzGq5hzP-643RxOMEDZjC0,2727
+mpytool/mpy.py,sha256=aaHG0bg04pYKq-VU84VYR9zCSAf_TKSDXCsdhHFRKew,46360
+mpytool/mpy_comm.py,sha256=QFHCIjdFGfDSLTVMdhAmIgz8J3QQ9VbNqzQGiaOfHKs,9149
+mpytool/mpytool.py,sha256=ZN8YG0lKMYQZARhQHXMdfi6Z9iZJqw8Yfikv89PMLDM,65824
+mpytool/terminal.py,sha256=YEWWwaGHISDpPWRileMPeh2drudEjF0lmjorXbrIWDY,2305
+mpytool/utils.py,sha256=Y6DNKgXYDwnVDLOVs671XjyL7HqnsW6FMHIgCJ5MgZM,1972
+mpytool-2.2.0.dist-info/licenses/LICENSE,sha256=wfMg5yKH2O86Digcowcm2g8Wh4zAo_gX-VqQXjmpf74,1078
+mpytool-2.2.0.dist-info/METADATA,sha256=GXhslqFH26oFKW3TT1ksZWbWImIg-BOm-wzAfsRTrW8,14902
+mpytool-2.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mpytool-2.2.0.dist-info/entry_points.txt,sha256=wmnyPWEKLEbPJFR98Cc2Ky0krbMxA2BcVsS5KCTGP8Q,49
+mpytool-2.2.0.dist-info/top_level.txt,sha256=4ZornVQbsgLIpB6d_5V1tOzX5bJvHxxDOuk8qFRjP2c,8
+mpytool-2.2.0.dist-info/RECORD,,

mpytool-2.1.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-mpytool/__init__.py,sha256=4BRbfLRLpReWcDDbUA1A2UO1B8sNa6O5lgXRObbnP20,266
-mpytool/conn.py,sha256=3WvSyeHY2qv5YT9qEEPqhSGj68wIJOXqz6G2bPCL_OM,4331
-mpytool/conn_serial.py,sha256=dcNQ9-utloZC6AyGaj0_BkEphpJOiOzudz2OQErFG8c,4013
-mpytool/conn_socket.py,sha256=EZh6KGMwPgNoNgl0wK4l47N9KVtaSLd3DeCTIiZ4bRw,1531
-mpytool/logger.py,sha256=e9xaDf52nsMXU4T4Kv_pogzGq5hzP-643RxOMEDZjC0,2727
-mpytool/mpy.py,sha256=NjQrjRh15tgAvJP--ZFrirjkS3PF4aQ-NvHi-RrHkQc,45625
-mpytool/mpy_comm.py,sha256=QFHCIjdFGfDSLTVMdhAmIgz8J3QQ9VbNqzQGiaOfHKs,9149
-mpytool/mpytool.py,sha256=9sRAqFwWbzbm-znaDmlsJzj8Dqg7IrQcBf_FPGVIaLA,64574
-mpytool/terminal.py,sha256=YEWWwaGHISDpPWRileMPeh2drudEjF0lmjorXbrIWDY,2305
-mpytool/utils.py,sha256=KbL3nDicLUT-qwP2jDl8ZCKOM1PPptZF_qxFUHYF5V8,2006
-mpytool-2.1.0.dist-info/licenses/LICENSE,sha256=wfMg5yKH2O86Digcowcm2g8Wh4zAo_gX-VqQXjmpf74,1078
-mpytool-2.1.0.dist-info/METADATA,sha256=4ZXTX1hUnXTnKZHKRLkGWwJwekg0P8rlfh4vIhcUjzw,13948
-mpytool-2.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mpytool-2.1.0.dist-info/entry_points.txt,sha256=wmnyPWEKLEbPJFR98Cc2Ky0krbMxA2BcVsS5KCTGP8Q,49
-mpytool-2.1.0.dist-info/top_level.txt,sha256=4ZornVQbsgLIpB6d_5V1tOzX5bJvHxxDOuk8qFRjP2c,8
-mpytool-2.1.0.dist-info/RECORD,,