mpytool 2.2.0__tar.gz → 2.2.2__tar.gz

{mpytool-2.2.0 → mpytool-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpytool
-Version: 2.2.0
+Version: 2.2.2
 Summary: MPY tool - manage files on devices running MicroPython
 Author-email: Pavel Revak <pavel.revak@gmail.com>
 License-Expression: MIT
@@ -446,7 +446,15 @@ Working only with MicroPython boards, not with CircuitPython
 
 - Linux
 - MacOS
-- Windows (limited support - REPL mode is disabled)
+- Windows
+
+### Windows notes
+
+All commands work on Windows including `repl`.
+
+**CMD.EXE**: ANSI colors are disabled, progress indicator works. Log messages use text prefixes (`E:`, `W:`, `I:`, `D:`).
+
+**Git Bash**: Full color support (sets `TERM` environment variable).
 
 ## Credits
 

{mpytool-2.2.0 → mpytool-2.2.2}/README.md

@@ -432,7 +432,15 @@ Working only with MicroPython boards, not with CircuitPython
 
 - Linux
 - MacOS
-- Windows (limited support - REPL mode is disabled)
+- Windows
+
+### Windows notes
+
+All commands work on Windows including `repl`.
+
+**CMD.EXE**: ANSI colors are disabled, progress indicator works. Log messages use text prefixes (`E:`, `W:`, `I:`, `D:`).
+
+**Git Bash**: Full color support (sets `TERM` environment variable).
 
 ## Credits
 

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool/conn.py

@@ -116,6 +116,9 @@ class Conn():
         line = self.read_until(b'\n', timeout)
         return line.strip(b'\r')
 
+    def close(self):
+        """Close connection"""
+
     def hard_reset(self):
         """Hardware reset (only available on serial connections)"""
         raise NotImplementedError("Hardware reset not available on this connection")

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool/conn_serial.py

@@ -17,15 +17,37 @@ class ConnSerial(_conn.Conn):
             self._serial = None
             raise _conn.ConnError(
                 f"Error opening serial port {serial_config['port']}") from err
+        # Windows: pyserial has no fd, select() works only with sockets
+        if not hasattr(self._serial, 'fd'):
+            self._has_data = self._has_data_polling
 
-    def __del__(self):
+    def close(self):
         if self._serial:
             self._serial.close()
+            self._serial = None
+
+    def __del__(self):
+        self.close()
 
     @property
     def fd(self):
         return self._serial.fd if self._serial else None
 
+    def _has_data_polling(self, timeout=0):
+        """Check if data is available using in_waiting (Windows)"""
+        try:
+            if self._serial.in_waiting > 0:
+                return True
+            if timeout > 0:
+                deadline = _time.time() + timeout
+                while _time.time() < deadline:
+                    if self._serial.in_waiting > 0:
+                        return True
+                    _time.sleep(0.001)
+            return False
+        except OSError:
+            return False
+
     def _read_available(self):
         """Read available data from serial port"""
         if self._serial is None:

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool/conn_socket.py

@@ -30,9 +30,13 @@ class ConnSocket(_conn.Conn):
         if log:
             log.info("connected")
 
-    def __del__(self):
+    def close(self):
         if self._socket:
             self._socket.close()
+            self._socket = None
+
+    def __del__(self):
+        self.close()
 
     @property
     def fd(self):

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool/logger.py

@@ -28,21 +28,31 @@ class SimpleColorLogger():
     def __init__(self, loglevel=1, verbose_level=0):
         self._loglevel = loglevel
         self._verbose_level = verbose_level
-        self._is_tty = (
-            _sys.stderr.isatty()
+        self._is_tty = _sys.stderr.isatty()
+        self._color = (
+            self._is_tty
             and _os.environ.get('NO_COLOR') is None
             and _os.environ.get('TERM') != 'dumb'
             and _os.environ.get('CI') is None
+            and (_sys.platform != 'win32' or _os.environ.get('TERM'))
         )
+        self._pending_line = False  # True when last output had no trailing newline
+
+    def _clear_pending(self):
+        """End pending progress line before printing a new message"""
+        if self._pending_line:
+            print(file=_sys.stderr)
+            self._pending_line = False
 
     def log(self, msg):
+        self._clear_pending()
         print(msg, file=_sys.stderr)
 
     def error(self, msg, *args):
         if args:
             msg = msg % args
         if self._loglevel >= 1:
-            if self._is_tty:
+            if self._color:
                 self.log(f"{self._BOLD_RED}{msg}{self._RESET}")
             else:
                 self.log(f"E: {msg}")
@@ -51,7 +61,7 @@ class SimpleColorLogger():
         if args:
             msg = msg % args
         if self._loglevel >= 2:
-            if self._is_tty:
+            if self._color:
                 self.log(f"{self._BOLD_YELLOW}{msg}{self._RESET}")
             else:
                 self.log(f"W: {msg}")
@@ -60,7 +70,7 @@ class SimpleColorLogger():
         if args:
             msg = msg % args
         if self._loglevel >= 3:
-            if self._is_tty:
+            if self._color:
                 self.log(f"{self._BOLD_MAGENTA}{msg}{self._RESET}")
             else:
                 self.log(f"I: {msg}")
@@ -69,7 +79,7 @@ class SimpleColorLogger():
         if args:
             msg = msg % args
         if self._loglevel >= 4:
-            if self._is_tty:
+            if self._color:
                 self.log(f"{self._BOLD_BLUE}{msg}{self._RESET}")
             else:
                 self.log(f"D: {msg}")
@@ -81,7 +91,10 @@ class SimpleColorLogger():
         # Skip progress updates (overwrite without newline) in non-TTY mode
         if overwrite and not self._is_tty and end != '\n':
             return
-        color_code = self.COLORS.get(color, self._BOLD_GREEN) if self._is_tty else ''
-        reset_code = self._RESET if self._is_tty else ''
-        clear = f'\r{self._CLEAR_LINE}' if self._is_tty and overwrite else ''
+        if not overwrite:
+            self._clear_pending()
+        color_code = self.COLORS.get(color, self._BOLD_GREEN) if self._color else ''
+        reset_code = self._RESET if self._color else ''
+        clear = f'\r{self._CLEAR_LINE}' if self._color and overwrite else ('\r' if self._is_tty and overwrite else '')
         print(f"{clear}{color_code}{msg}{reset_code}", end=end, file=_sys.stderr, flush=True)
+        self._pending_line = (end != '\n')

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool/mpy_comm.py

@@ -20,13 +20,42 @@ class MpyError(Exception):
 
 class CmdError(MpyError):
     """Command execution error on device"""
+
+    # Known MicroPython OSError codes
+    _OSERROR_MESSAGES = {
+        '2': 'No such file or directory',
+        '13': 'Permission denied',
+        '17': 'File exists',
+        '19': 'No such device',
+        '21': 'Is a directory',
+        '22': 'Invalid argument',
+        '28': 'No space left on device',
+        '30': 'Read-only filesystem',
+        '110': 'Connection timed out',
+        '113': 'No route to host',
+    }
+
     def __init__(self, cmd, result, error):
         self._cmd = cmd
         self._result = result
         self._error = error.decode('utf-8')
         super().__init__(self.__str__())
 
+    def _friendly_error(self):
+        """Translate known OSError codes to human-readable messages"""
+        import re
+        match = re.search(r'OSError: (\d+)', self._error)
+        if match:
+            code = match.group(1)
+            msg = self._OSERROR_MESSAGES.get(code)
+            if msg:
+                return f'OSError: {msg} (errno {code})'
+        return None
+
     def __str__(self):
+        friendly = self._friendly_error()
+        if friendly:
+            return friendly
         res = f'Command:\n  {self._cmd}\n'
         if self._result:
             res += f'Result:\n  {self._result}\n'

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool/mpytool.py

@@ -30,7 +30,7 @@ def _join_remote_path(base, name):
     if base == '/':
         return '/' + name
     elif base:
-        return base + '/' + name
+        return base.rstrip('/') + '/' + name
     else:
         return name
 
@@ -119,7 +119,10 @@ class MpyTool():
         chunk_str = f"{chunk // 1024}K" if chunk >= 1024 else str(chunk)
         compress = self._mpy._detect_deflate() if self._compress is None else self._compress
         compress_str = "on" if compress else "off"
-        self.verbose(f"COPY (chunk: {chunk_str}, compress: {compress_str})", 1)
+        if self._verbose >= 2:
+            self.verbose(f"COPY (chunk: {chunk_str}, compress: {compress_str})")
+        else:
+            self.verbose("COPY")
 
     @staticmethod
     def _format_local_path(path):
@@ -157,7 +160,7 @@ class MpyTool():
         return info
 
     def _format_line(self, status, total, encodings=None):
-        """Format progress/skip line: [2/5] 100% 24.1K source -> dest (base64)"""
+        """Format verbose line: [2/5] 100% 24.1K source -> dest (base64)"""
         size_str = self.format_size(total)
         multi = self._progress_total_files > 1
         if multi:
@@ -170,6 +173,22 @@ class MpyTool():
         enc = self._format_encoding_info(encodings, pad=multi) if encodings else (" " * self._ENC_WIDTH if multi else "")
         return f"{prefix:>7} {status} {size_str:>5} {self._progress_src:<{src_w}} -> {self._progress_dst:<{dst_w}}{enc}"
 
+    def _format_compact_progress(self, status, total):
+        """Format compact progress line: [2/5]  45% 24.1K source"""
+        size_str = self.format_size(total)
+        multi = self._progress_total_files > 1
+        if multi:
+            width = len(str(self._progress_total_files))
+            prefix = f"[{self._progress_current_file:>{width}}/{self._progress_total_files}]"
+        else:
+            prefix = ""
+        return f"{prefix:>7} {status} {size_str:>5} {self._progress_src}"
+
+    def _format_compact_complete(self, total):
+        """Format compact complete line: 24.1K source -> dest"""
+        size_str = self.format_size(total)
+        return f" {size_str:>5} {self._progress_src} -> {self._progress_dst}"
+
     def _format_progress_line(self, percent, total, encodings=None):
         return self._format_line(f"{percent:3d}%", total, encodings)
 
@@ -179,19 +198,22 @@ class MpyTool():
     def _progress_callback(self, transferred, total):
         """Callback for file transfer progress"""
         percent = (transferred * 100 // total) if total > 0 else 100
-        line = self._format_progress_line(percent, total)
+        if self._verbose >= 2:
+            line = self._format_progress_line(percent, total)
+        else:
+            line = self._format_compact_progress(f"{percent:3d}%", total)
         if self._is_debug:
-            # Debug mode: always newlines
             self.verbose(line, color='cyan')
         else:
-            # Normal mode: overwrite line
             self.verbose(line, color='cyan', end='', overwrite=True)
 
     def _progress_complete(self, total, encodings=None):
         """Mark current file as complete"""
-        line = self._format_progress_line(100, total, encodings)
+        if self._verbose >= 2:
+            line = self._format_progress_line(100, total, encodings)
+        else:
+            line = self._format_compact_complete(total)
         if self._is_debug:
-            # Already printed with newline in callback
             pass
         else:
             self.verbose(line, color='cyan', overwrite=True)
@@ -258,23 +280,24 @@ class MpyTool():
             # For files, add basename if dst_path ends with /
             basename = _os.path.basename(src_path)
             if basename and not _os.path.basename(dst_path):
-                dst_path = _os.path.join(dst_path, basename)
+                dst_path = _join_remote_path(dst_path, basename)
             files[dst_path] = _os.path.getsize(src_path)
         elif _os.path.isdir(src_path):
             # For directories, mimic _put_dir behavior
             if add_src_basename:
                 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)
             for root, dirs, filenames in _os.walk(src_path, topdown=True):
-                dirs[:] = [d for d in dirs if not self._is_excluded(d)]
-                filenames = [f for f in filenames if not self._is_excluded(f)]
-                rel_path = _os.path.relpath(root, src_path)
+                dirs[:] = sorted(d for d in dirs if not self._is_excluded(d))
+                filenames = sorted(f for f in filenames if not self._is_excluded(f))
+                rel_path = _os.path.relpath(root, src_path).replace(_os.sep, '/')
                 if rel_path == '.':
                     rel_path = ''
                 for file_name in filenames:
                     spath = _os.path.join(root, file_name)
-                    dpath = _os.path.join(dst_path, rel_path, file_name) if rel_path else _os.path.join(dst_path, file_name)
+                    dpath = _join_remote_path(
+                        _join_remote_path(dst_path, rel_path), file_name)
                     files[dpath] = _os.path.getsize(spath)
         return files
 
@@ -466,10 +489,10 @@ class MpyTool():
             parts.append(f"speedup {speedup:.1f}x")
         summary = "  ".join(parts)
         if self._skipped_files > 0:
-            file_info = f"{self._stats_transferred_files} transferred, {self._skipped_files} skipped"
+            file_info = f"{self._stats_transferred_files} transferred, {self._skipped_files} unchanged"
         else:
             file_info = f"{total_files} files"
-        self.verbose(f"  {summary}  ({file_info})", color='green')
+        self.verbose(f" {summary}  ({file_info})", color='green')
 
     @classmethod
     def print_tree(cls, tree, prefix='', print_size=True, first=True, last=True):
@@ -518,18 +541,26 @@ class MpyTool():
         """Upload file data to device with stats tracking and progress display"""
         file_size = len(data)
         self._stats_total_bytes += file_size
+        if show_progress and self._verbose >= 1:
+            self._progress_current_file += 1
+            self._set_progress_info(src_path, dst_path, False, True)
+            # Show CHCK status during checksum verification
+            if self._verbose >= 2:
+                line = self._format_line("CHCK", file_size)
+            else:
+                line = self._format_compact_progress("CHCK", file_size)
+            self.verbose(line, color='cyan', end='', overwrite=True)
         if not self._file_needs_update(data, dst_path):
             self._skipped_files += 1
-            if show_progress and self._verbose >= 1:
-                self._progress_current_file += 1
-                self._set_progress_info(src_path, dst_path, False, True)
-                self.verbose(self._format_skip_line(file_size), color='yellow')
+            if show_progress and self._verbose >= 2:
+                self.verbose(self._format_skip_line(file_size), color='yellow', overwrite=True)
+            elif show_progress and self._verbose >= 1:
+                # Erase CHCK line (next file's progress will overwrite)
+                self.verbose("", end='', overwrite=True)
             return False  # skipped
         self._stats_transferred_bytes += file_size
         self._stats_transferred_files += 1
         if show_progress and self._verbose >= 1:
-            self._progress_current_file += 1
-            self._set_progress_info(src_path, dst_path, False, True)
             encodings, wire = self._mpy.put(data, dst_path, self._progress_callback, self._compress)
             self._stats_wire_bytes += wire
             self._progress_complete(file_size, encodings)
@@ -556,25 +587,25 @@ class MpyTool():
         self.verbose(f"PUT DIR: {src_path} -> {dst_path}", 2)
         created_dirs = set()
         for path, dirs, files in _os.walk(src_path, topdown=True):
-            dirs[:] = [d for d in dirs if not self._is_excluded(d)]
-            files = [f for f in files if not self._is_excluded(f)]
+            dirs[:] = sorted(d for d in dirs if not self._is_excluded(d))
+            files = sorted(f for f in files if not self._is_excluded(f))
             if not files:
                 continue
-            rel_path = _os.path.relpath(path, src_path)
-            rel_path = _os.path.join(dst_path, '' if rel_path == '.' else rel_path)
-            if rel_path and rel_path not in created_dirs:
-                self.verbose(f'MKDIR: {rel_path}', 2)
-                self._mpy.mkdir(rel_path)
-                created_dirs.add(rel_path)
+            rel_path = _os.path.relpath(path, src_path).replace(_os.sep, '/')
+            remote_dir = _join_remote_path(dst_path, '' if rel_path == '.' else rel_path)
+            if remote_dir and remote_dir not in created_dirs:
+                self.verbose(f'MKDIR: {remote_dir}', 2)
+                self._mpy.mkdir(remote_dir)
+                created_dirs.add(remote_dir)
             for file_name in files:
                 spath = _os.path.join(path, file_name)
                 with open(spath, 'rb') as f:
-                    self._upload_file(f.read(), spath, _os.path.join(rel_path, file_name), show_progress)
+                    self._upload_file(f.read(), spath, _join_remote_path(remote_dir, file_name), show_progress)
 
     def _put_file(self, src_path, dst_path, show_progress=True):
         basename = _os.path.basename(src_path)
         if basename and not _os.path.basename(dst_path):
-            dst_path = _os.path.join(dst_path, basename)
+            dst_path = _join_remote_path(dst_path, basename)
         self.verbose(f"PUT FILE: {src_path} -> {dst_path}", 2)
         with open(src_path, 'rb') as f:
             data = f.read()
@@ -597,7 +628,7 @@ class MpyTool():
             self._progress_current_file += 1
             self._set_progress_info(src_path, dst_path, True, False)
             data = self._mpy.get(src_path, self._progress_callback)
-            self._progress_complete(len(data))
+            self._progress_complete(len(data), None)
         else:
             data = self._mpy.get(src_path)
         file_size = len(data)
@@ -1396,7 +1427,7 @@ Commands (: prefix = device path, :/ = root, : = CWD):
     --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]
+  repl                          interactive REPL
   exec {code}                   execute Python code
   info                          show device information
   flash                         show flash/partitions info

mpytool-2.2.2/mpytool/terminal.py

@@ -0,0 +1,80 @@
+"""MicroPython tool: terminal connection
+
+Base class with common terminal functionality.
+Platform-specific implementations in terminal_unix.py and terminal_win.py.
+"""
+
+import sys as _sys
+
+AVAILABLE = False
+
+
+class TerminalBase:
+    """Common terminal functionality for interactive REPL"""
+
+    def __init__(self, conn, log):
+        self._log = log
+        self._conn = conn
+        self._running = None
+
+    def _setup(self):
+        """Set terminal to raw mode (platform-specific)"""
+        raise NotImplementedError
+
+    def _restore(self):
+        """Restore original terminal mode (platform-specific)"""
+        raise NotImplementedError
+
+    def read(self):
+        """Read input from keyboard (platform-specific)"""
+        raise NotImplementedError
+
+    def _loop(self):
+        """Main event loop (platform-specific)"""
+        raise NotImplementedError
+
+    def write(self, buf):
+        _sys.stdout.buffer.raw.write(buf)
+
+    def _read_event_terminal(self):
+        data = self.read()
+        self._log.info('from terminal: %s', data)
+        if 0x1d in data:  # CTRL + ]
+            self._running = False
+            return
+        if data:
+            self._conn.write(data)
+
+    def _read_event_device(self):
+        data = self._conn.read()
+        self._log.info('from device: %s', data)
+        if data:
+            self.write(data)
+
+    def _flush_device(self):
+        data = self._conn.flush()
+        if data:
+            self.write(data)
+
+    def run(self):
+        self._setup()
+        self._running = True
+        try:
+            self._flush_device()
+            self._loop()
+        except OSError as err:
+            if self._log:
+                self._log.error(err)
+        self._restore()
+        self.write(b'\r\n')
+
+
+try:
+    from mpytool.terminal_unix import Terminal
+    AVAILABLE = True
+except ImportError:
+    try:
+        from mpytool.terminal_win import Terminal
+        AVAILABLE = True
+    except ImportError:
+        pass

mpytool-2.2.2/mpytool/terminal_unix.py

@@ -0,0 +1,45 @@
+"""MicroPython tool: Unix terminal (tty/termios/select)"""
+
+import sys as _sys
+import select as _select
+import tty as _tty
+import termios as _termios
+
+from mpytool.terminal import TerminalBase
+
+
+class Terminal(TerminalBase):
+
+    def __init__(self, conn, log):
+        super().__init__(conn, log)
+        self._stdin_fd = _sys.stdin.fileno()
+        self._orig_attr = _termios.tcgetattr(self._stdin_fd)
+
+    def __del__(self):
+        if self._orig_attr:
+            _termios.tcsetattr(
+                self._stdin_fd, _termios.TCSANOW, self._orig_attr)
+
+    def _setup(self):
+        _tty.setraw(self._stdin_fd)
+
+    def _restore(self):
+        if self._orig_attr:
+            _termios.tcsetattr(
+                self._stdin_fd, _termios.TCSANOW, self._orig_attr)
+            self._orig_attr = None
+
+    def read(self):
+        return _sys.stdin.buffer.raw.read(1)
+
+    def _loop(self):
+        select_fds = [self._stdin_fd, self._conn.fd]
+        self._log.info("select: %s", select_fds)
+        while self._running:
+            ret = _select.select(select_fds, [], [], 1)
+            self._log.info("selected: %s", ret)
+            if ret[0]:
+                if self._stdin_fd in ret[0]:
+                    self._read_event_terminal()
+                if self._conn.fd in ret[0]:
+                    self._read_event_device()

mpytool-2.2.2/mpytool/terminal_win.py

@@ -0,0 +1,88 @@
+"""MicroPython tool: Windows terminal (msvcrt/ctypes)"""
+
+import sys as _sys
+import time as _time
+import ctypes as _ctypes
+import msvcrt as _msvcrt
+
+from mpytool.terminal import TerminalBase
+
+# kernel32 console mode constants
+_STD_INPUT_HANDLE = -10
+_STD_OUTPUT_HANDLE = -11
+_ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+_ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+
+_kernel32 = _ctypes.windll.kernel32
+
+# Windows scan code to ANSI escape sequence mapping
+# msvcrt.getch() returns 0x00 or 0xE0 prefix + scan code for special keys
+_SCAN_TO_ANSI = {
+    72: b'\x1b[A',   # Up
+    80: b'\x1b[B',   # Down
+    77: b'\x1b[C',   # Right
+    75: b'\x1b[D',   # Left
+    71: b'\x1b[H',   # Home
+    79: b'\x1b[F',   # End
+    83: b'\x1b[3~',  # Delete
+    82: b'\x1b[2~',  # Insert
+    73: b'\x1b[5~',  # Page Up
+    81: b'\x1b[6~',  # Page Down
+}
+
+
+class Terminal(TerminalBase):
+
+    def __init__(self, conn, log):
+        super().__init__(conn, log)
+        self._stdin_h = _kernel32.GetStdHandle(_STD_INPUT_HANDLE)
+        self._stdout_h = _kernel32.GetStdHandle(_STD_OUTPUT_HANDLE)
+        self._orig_in_mode = _ctypes.c_uint32()
+        self._orig_out_mode = _ctypes.c_uint32()
+        _kernel32.GetConsoleMode(
+            self._stdin_h, _ctypes.byref(self._orig_in_mode))
+        _kernel32.GetConsoleMode(
+            self._stdout_h, _ctypes.byref(self._orig_out_mode))
+
+    def __del__(self):
+        self._restore()
+
+    def _setup(self):
+        # Input: disable line input, echo, processed input
+        # enable virtual terminal input (Win10+)
+        _kernel32.SetConsoleMode(
+            self._stdin_h, _ENABLE_VIRTUAL_TERMINAL_INPUT)
+        # Output: enable ANSI escape processing
+        out_mode = self._orig_out_mode.value | _ENABLE_VIRTUAL_TERMINAL_PROCESSING
+        _kernel32.SetConsoleMode(self._stdout_h, out_mode)
+
+    def _restore(self):
+        if self._orig_in_mode.value:
+            _kernel32.SetConsoleMode(self._stdin_h, self._orig_in_mode)
+            self._orig_in_mode = _ctypes.c_uint32()
+        if self._orig_out_mode.value:
+            _kernel32.SetConsoleMode(self._stdout_h, self._orig_out_mode)
+            self._orig_out_mode = _ctypes.c_uint32()
+
+    def write(self, buf):
+        _sys.stdout.buffer.raw.write(buf)
+        _sys.stdout.buffer.raw.flush()
+
+    def read(self):
+        byte = _msvcrt.getch()
+        if byte in (b'\x00', b'\xe0'):
+            scan = _msvcrt.getch()
+            return _SCAN_TO_ANSI.get(scan[0], b'')
+        return byte
+
+    def _loop(self):
+        while self._running:
+            activity = False
+            if _msvcrt.kbhit():
+                self._read_event_terminal()
+                activity = True
+            if self._conn._has_data(0):
+                self._read_event_device()
+                activity = True
+            if not activity:
+                _time.sleep(0.002)

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool/utils.py

@@ -2,6 +2,8 @@
 
 import sys
 
+from serial.tools.list_ports import comports as _comports
+
 
 def is_remote_path(path: str) -> bool:
     """Check if path is remote (starts with :)"""
@@ -74,7 +76,9 @@ def detect_serial_ports() -> list[str]:
             "/dev/ttyACM*",
             "/dev/ttyUSB*",
         ]
-    # Windows not yet supported
+    elif sys.platform == "win32":
+        return sorted(
+            p.device for p in _comports() if p.vid is not None)
 
     ports = []
     for pattern in patterns:

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpytool
-Version: 2.2.0
+Version: 2.2.2
 Summary: MPY tool - manage files on devices running MicroPython
 Author-email: Pavel Revak <pavel.revak@gmail.com>
 License-Expression: MIT
@@ -446,7 +446,15 @@ Working only with MicroPython boards, not with CircuitPython
 
 - Linux
 - MacOS
-- Windows (limited support - REPL mode is disabled)
+- Windows
+
+### Windows notes
+
+All commands work on Windows including `repl`.
+
+**CMD.EXE**: ANSI colors are disabled, progress indicator works. Log messages use text prefixes (`E:`, `W:`, `I:`, `D:`).
+
+**Git Bash**: Full color support (sets `TERM` environment variable).
 
 ## Credits
 

{mpytool-2.2.0 → mpytool-2.2.2}/mpytool.egg-info/SOURCES.txt

@@ -10,6 +10,8 @@ mpytool/mpy.py
 mpytool/mpy_comm.py
 mpytool/mpytool.py
 mpytool/terminal.py
+mpytool/terminal_unix.py
+mpytool/terminal_win.py
 mpytool/utils.py
 mpytool.egg-info/PKG-INFO
 mpytool.egg-info/SOURCES.txt

{mpytool-2.2.0 → mpytool-2.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mpytool"
-version = "2.2.0"
+version = "2.2.2"
 description = "MPY tool - manage files on devices running MicroPython"
 readme = "README.md"
 license = "MIT"

{mpytool-2.2.0 → mpytool-2.2.2}/tests/test_errors.py

@@ -37,6 +37,37 @@ class TestCmdError(unittest.TestCase):
     def test_is_mpy_error(self):
         self.assertTrue(issubclass(CmdError, MpyError))
 
+    def test_friendly_oserror_no_space(self):
+        err = CmdError("f.write(b'data')", b"", b"Traceback (most recent call last):\n  File \"<stdin>\", line 1, in <module>\nOSError: 28")
+        msg = str(err)
+        self.assertIn("No space left on device", msg)
+        self.assertIn("errno 28", msg)
+        self.assertNotIn("Traceback", msg)
+
+    def test_friendly_oserror_enoent(self):
+        err = CmdError("open('x')", b"", b"OSError: 2")
+        msg = str(err)
+        self.assertIn("No such file or directory", msg)
+        self.assertIn("errno 2", msg)
+
+    def test_friendly_oserror_read_only(self):
+        err = CmdError("f.write(b'')", b"", b"OSError: 30")
+        msg = str(err)
+        self.assertIn("Read-only filesystem", msg)
+
+    def test_unknown_oserror_shows_full(self):
+        err = CmdError("cmd", b"", b"OSError: 999")
+        msg = str(err)
+        self.assertIn("cmd", msg)
+        self.assertIn("OSError: 999", msg)
+
+    def test_non_oserror_shows_full(self):
+        err = CmdError("cmd", b"result", b"ValueError: bad")
+        msg = str(err)
+        self.assertIn("cmd", msg)
+        self.assertIn("result", msg)
+        self.assertIn("ValueError: bad", msg)
+
 
 class TestPathErrors(unittest.TestCase):
     def test_path_not_found(self):

{mpytool-2.2.0 → mpytool-2.2.2}/tests/test_integration.py

@@ -31,6 +31,7 @@ class TestDeviceConnection(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_connection_established(self):
         """Test that connection is established"""
@@ -64,6 +65,7 @@ class TestFileOperations(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_mkdir(self):
         """Test creating directory"""
@@ -143,6 +145,7 @@ class TestExec(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_exec_simple(self):
         """Test simple code execution"""
@@ -188,7 +191,7 @@ class TestReplRecovery(unittest.TestCase):
         # Close connection WITHOUT exiting raw REPL
         # This simulates a crash or unexpected disconnect
         del mpy1
-        del conn1
+        conn1.close()
 
         # Second connection - device is still in raw REPL mode
         conn2 = ConnSerial(port=DEVICE_PORT, baudrate=115200)
@@ -201,6 +204,7 @@ class TestReplRecovery(unittest.TestCase):
             self.assertEqual(result, 2)
         finally:
             mpy2.comm.exit_raw_repl()
+            conn2.close()
 
 
 @requires_device
@@ -216,6 +220,7 @@ class TestDeviceInfo(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_get_platform(self):
         """Test getting platform info"""
@@ -271,6 +276,7 @@ class TestCwdOperations(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def setUp(self):
         # Always start from root
@@ -420,6 +426,7 @@ class TestCpCommand(unittest.TestCase):
         if os.path.exists(cls.LOCAL_DIR):
             shutil.rmtree(cls.LOCAL_DIR)
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_upload_file(self):
         """Test cp local file to remote"""
@@ -524,6 +531,7 @@ class TestMvCommand(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_rename_file(self):
         """Test mv rename file"""
@@ -578,6 +586,7 @@ class TestDeleteCommand(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_delete_file(self):
         """Test rm single file"""
@@ -649,6 +658,7 @@ class TestSkipUnchangedFiles(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_hashfile(self):
         """Test hashfile method returns correct SHA256"""
@@ -712,6 +722,7 @@ class TestEncodingAndCompression(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_text_upload_uses_raw(self):
         """Test that text files use raw encoding"""
@@ -792,6 +803,7 @@ class TestCpWithFlags(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_cp_with_combined_flags(self):
         """Test cp -fz with combined flags"""
@@ -845,6 +857,7 @@ class TestSleepCommand(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_sleep_delays_execution(self):
         """Test that sleep actually delays execution"""
@@ -886,6 +899,7 @@ class TestSpecialCharacterFilenames(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_filename_with_equals_sign(self):
         """Test file with equals sign in name (mpremote #18658)"""
@@ -979,6 +993,7 @@ class TestUnicodeFilenames(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_czech_filename(self):
         """Test file with Czech characters in name"""
@@ -1081,6 +1096,7 @@ class TestCpSpecialFilenames(unittest.TestCase):
         if os.path.exists(cls.LOCAL_DIR):
             shutil.rmtree(cls.LOCAL_DIR)
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_upload_file_with_equals(self):
         """Test cp upload file with equals sign (mpremote #18658)"""
@@ -1182,6 +1198,7 @@ class TestErrorMessages(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_get_nonexistent_file(self):
         """Test get on nonexistent file raises FileNotFound"""
@@ -1236,6 +1253,7 @@ class TestLargeFileTransfer(unittest.TestCase):
         except Exception:
             pass
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_upload_10kb_file(self):
         """Test upload of 10KB file"""
@@ -1285,6 +1303,7 @@ class TestPartitions(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_partitions_list(self):
         """Test listing partitions on ESP32"""
@@ -1338,6 +1357,7 @@ class TestFlashRP2(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
         cls.mpy.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_flash_info(self):
         """Test getting flash info on RP2"""
@@ -1392,6 +1412,7 @@ class TestRawPasteMode(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
         cls.comm.exit_raw_repl()
+        cls.conn.close()
 
     def test_01_raw_paste_simple(self):
         """Test simple code execution via raw-paste"""

{mpytool-2.2.0 → mpytool-2.2.2}/tests/test_utils.py

@@ -149,11 +149,13 @@ class TestDetectSerialPorts(unittest.TestCase):
         self.assertIn("/dev/ttyUSB0", ports)
 
     @patch("sys.platform", "win32")
-    @patch("glob.glob")
-    def test_windows_not_supported(self, mock_glob):
+    @patch("mpytool.utils._comports")
+    def test_windows_comports(self, mock_comports):
+        mock_port1 = type('PortInfo', (), {'device': 'COM3', 'vid': 0x2E8A})()
+        mock_port2 = type('PortInfo', (), {'device': 'COM1', 'vid': None})()
+        mock_comports.return_value = [mock_port1, mock_port2]
         ports = detect_serial_ports()
-        self.assertEqual(ports, [])
-        mock_glob.assert_not_called()
+        self.assertEqual(ports, ['COM3'])
 
     @patch("sys.platform", "linux")
     @patch("glob.glob")

mpytool-2.2.0/mpytool/terminal.py

@@ -1,76 +0,0 @@
-"""MicroPython tool: terminal connection"""
-
-AVAILABLE = False
-
-try:
-    import sys as _sys
-    import select as _select
-    import tty as _tty
-    import termios as _termios
-
-    AVAILABLE = True
-
-    class Terminal:
-        def __init__(self, conn, log):
-            self._log = log
-            self._conn = conn
-            self._stdin_fd = _sys.stdin.fileno()
-            self._last_attr = _termios.tcgetattr(self._stdin_fd)
-            self._running = None
-
-        def __del__(self):
-            if self._last_attr:
-                _termios.tcsetattr(self._stdin_fd, _termios.TCSANOW, self._last_attr)
-
-        def read(self):
-            return _sys.stdin.buffer.raw.read(1)
-
-        def write(self, buf):
-            _sys.stdout.buffer.raw.write(buf)
-
-        def _read_event_terminal(self):
-            data = self.read()
-            self._log.info('from terminal: %s', data)
-            if 0x1d in data:  # CTRL + ]
-                self._running = False
-            self._conn.write(data)
-
-        def _read_event_device(self):
-            data = self._conn.read()
-            self._log.info('from device: %s', data)
-            if data:
-                self.write(data)
-
-        def _flush_device(self):
-            data = self._conn.flush()
-            if data:
-                self.write(data)
-
-        def _read_event(self, event):
-            if self._stdin_fd in event:
-                self._read_event_terminal()
-            if self._conn.fd in event:
-                self._read_event_device()
-
-        def run(self):
-            _tty.setraw(self._stdin_fd)
-            self._running = True
-            try:
-                self._flush_device()
-                select_fds = [self._stdin_fd, self._conn.fd, ]
-                self._log.info("select: %s", select_fds)
-                while self._running:
-                    ret = _select.select(select_fds, [], [], 1)
-                    self._log.info("selected: %s", ret)
-                    if ret[0]:
-                        self._read_event(ret[0])
-            except OSError as err:
-                if self._log:
-                    self._log.error(err)
-            _termios.tcsetattr(self._stdin_fd, _termios.TCSANOW, self._last_attr)
-            self._last_attr = None
-            self.write(b'\r\n')
-
-
-except ImportError:
-    pass