mpytool 2.2.0__tar.gz → 2.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpytool
-Version: 2.2.0
+Version: 2.2.1
 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.1}/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.1}/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.1}/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.1}/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.1}/mpytool/logger.py

@@ -28,11 +28,13 @@ 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'))
         )
 
     def log(self, msg):
@@ -42,7 +44,7 @@ class SimpleColorLogger():
         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 +53,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 +62,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 +71,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 +83,7 @@ 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 ''
+        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)

{mpytool-2.2.0 → mpytool-2.2.1}/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
 
@@ -258,23 +258,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)
+                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
 
@@ -560,21 +561,21 @@ class MpyTool():
             files = [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()
@@ -1396,7 +1397,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.1/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.1/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.1/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.1}/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.1}/mpytool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpytool
-Version: 2.2.0
+Version: 2.2.1
 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.1}/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.1}/pyproject.toml

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

{mpytool-2.2.0 → mpytool-2.2.1}/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.1}/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