mpytool 2.2.3__tar.gz → 2.2.4__tar.gz

{mpytool-2.2.3 → mpytool-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpytool
-Version: 2.2.3
+Version: 2.2.4
 Summary: MPY tool - manage files on devices running MicroPython
 Author-email: Pavel Revak <pavel.revak@gmail.com>
 License-Expression: MIT
@@ -103,6 +103,7 @@ $ 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
+$ mpytool cp -m myapp :/            # compile .py to .mpy via mpy-cross
 ```
 
 Path semantics: `:` = device CWD, `:/` = device root. Trailing `/` on source = copy contents only.
@@ -114,11 +115,20 @@ Use `-f` or `--force` to upload all files regardless.
 $ mpytool cp -z main.py :/           # force compression (auto-detected by default)
 $ mpytool cp --no-compress data.bin :/  # disable compression
 $ mpytool -c 8K cp main.py :/        # set chunk size (512, 1K, 2K, 4K, 8K, 16K, 32K)
+$ mpytool cp -m myapp :/             # compile .py to .mpy before upload
+$ mpytool cp -fm myapp :/            # force upload + compile .mpy
 ```
 
 Compression is auto-detected based on device RAM and deflate module availability.
 Chunk size is auto-detected based on free RAM (larger chunks = faster transfer).
 
+The `-m`/`--mpy` flag compiles `.py` files to `.mpy` bytecode using `mpy-cross` before upload.
+Compiled files are cached in `__pycache__/` (recompiled only when source changes).
+`boot.py` and `main.py` are always uploaded as `.py` (firmware requirement).
+Requires `mpy-cross` in PATH (`pip install mpy-cross`). If mpy-cross version differs
+from device, automatically uses `-b` flag to target the correct bytecode version.
+If `mpy-cross` is not found, falls back to uploading `.py` with a warning.
+
 ### Move/rename on device
 ```
 $ mpytool mv :/old.py :/new.py      # rename file

{mpytool-2.2.3 → mpytool-2.2.4}/README.md

@@ -89,6 +89,7 @@ $ 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
+$ mpytool cp -m myapp :/            # compile .py to .mpy via mpy-cross
 ```
 
 Path semantics: `:` = device CWD, `:/` = device root. Trailing `/` on source = copy contents only.
@@ -100,11 +101,20 @@ Use `-f` or `--force` to upload all files regardless.
 $ mpytool cp -z main.py :/           # force compression (auto-detected by default)
 $ mpytool cp --no-compress data.bin :/  # disable compression
 $ mpytool -c 8K cp main.py :/        # set chunk size (512, 1K, 2K, 4K, 8K, 16K, 32K)
+$ mpytool cp -m myapp :/             # compile .py to .mpy before upload
+$ mpytool cp -fm myapp :/            # force upload + compile .mpy
 ```
 
 Compression is auto-detected based on device RAM and deflate module availability.
 Chunk size is auto-detected based on free RAM (larger chunks = faster transfer).
 
+The `-m`/`--mpy` flag compiles `.py` files to `.mpy` bytecode using `mpy-cross` before upload.
+Compiled files are cached in `__pycache__/` (recompiled only when source changes).
+`boot.py` and `main.py` are always uploaded as `.py` (firmware requirement).
+Requires `mpy-cross` in PATH (`pip install mpy-cross`). If mpy-cross version differs
+from device, automatically uses `-b` flag to target the correct bytecode version.
+If `mpy-cross` is not found, falls back to uploading `.py` with a warning.
+
 ### Move/rename on device
 ```
 $ mpytool mv :/old.py :/new.py      # rename file

{mpytool-2.2.3 → mpytool-2.2.4}/mpytool/mpy.py

@@ -568,9 +568,11 @@ def _mt_pfind(label):
             mpy_int = self._mpy_comm.exec_eval("sys.implementation._mpy")
             mpy_ver = mpy_int & 0xFF
             mpy_sub = (mpy_int >> 8) & 3
+            mpy_arch = (mpy_int >> 10) & 0x0F
         except (_mpy_comm.CmdError, AttributeError):
             mpy_ver = None
             mpy_sub = None
+            mpy_arch = 0
 
         return {
             'platform': platform,
@@ -580,6 +582,7 @@ def _mt_pfind(label):
             'machine': machine,
             'mpy_ver': mpy_ver,
             'mpy_sub': mpy_sub,
+            'mpy_arch': mpy_arch,
         }
 
     def memory(self):

mpytool-2.2.4/mpytool/mpy_cross.py

@@ -0,0 +1,155 @@
+"""Mpy-cross compilation support for MicroPython .mpy files"""
+
+import fnmatch as _fnmatch
+import os as _os
+import re as _re
+import shutil as _shutil
+import subprocess as _subprocess
+
+
+# Native arch index from sys.implementation._mpy bits 10-13
+_MPY_ARCH_NAMES = (
+    None, 'x86', 'x64', 'armv6', 'armv6m', 'armv7m', 'armv7em',
+    'armv7emsp', 'armv7emdp', 'xtensa', 'xtensawin', 'rv32imc',
+    'rv64imc',
+)
+
+_BOOT_FILES = frozenset(('boot.py', 'main.py'))
+
+
+class MpyCross:
+    """Mpy-cross compiler wrapper with caching
+
+    Compiles .py files to .mpy bytecode via mpy-cross.
+    Cached in __pycache__/name.mpy-X.Y-arch.mpy with mtime check.
+    """
+
+    def __init__(self, log, verbose_fn=None):
+        self._log = log
+        self._verbose_fn = verbose_fn
+        self.active = False
+        self._ver = None  # (major, sub) device mpy version
+        self._arch = None  # architecture name for cache key
+        self._args = []  # extra mpy-cross args (-b, -march)
+        self.compiled = {}  # {src_path: cache_path}
+
+    def _verbose(self, msg, level=1):
+        if self._verbose_fn:
+            self._verbose_fn(msg, level)
+
+    def init(self, platform_info):
+        """Initialize: find mpy-cross, check version, detect arch
+
+        Arguments:
+            platform_info: dict from Mpy.platform()
+
+        Sets self.active = True on success, False on failure.
+        """
+        self.active = False
+        mpy_cross_bin = _shutil.which('mpy-cross')
+        if not mpy_cross_bin:
+            self._log.warning(
+                'mpy-cross not found in PATH (pip install mpy-cross),'
+                ' uploading .py files')
+            return
+        # Get mpy-cross version
+        result = _subprocess.run(
+            [mpy_cross_bin, '--version'],
+            capture_output=True, text=True, timeout=10)
+        output = result.stdout + result.stderr
+        match = _re.search(r'mpy v(\d+)\.(\d+)', output)
+        if not match:
+            self._log.warning(
+                f'Cannot parse mpy-cross version: {output.strip()},'
+                ' uploading .py files')
+            return
+        cross_ver = int(match.group(1))
+        cross_sub = int(match.group(2))
+        # Get device mpy version and architecture
+        dev_ver = platform_info.get('mpy_ver')
+        dev_sub = platform_info.get('mpy_sub')
+        if dev_ver is None:
+            self._log.warning(
+                'Device does not report mpy version, uploading .py files')
+            return
+        self._ver = (dev_ver, dev_sub)
+        self._args = ['-O2']
+        # Bytecode version targeting
+        cross_str = f'v{cross_ver}.{cross_sub}'
+        if cross_ver != dev_ver or cross_sub != dev_sub:
+            self._args = ['-b', f'{dev_ver}.{dev_sub}']
+            cross_str += f' -> v{dev_ver}.{dev_sub}'
+        # Native architecture for @native/@viper support
+        dev_arch = platform_info.get('mpy_arch', 0)
+        arch_name = None
+        if dev_arch and dev_arch < len(_MPY_ARCH_NAMES):
+            arch_name = _MPY_ARCH_NAMES[dev_arch]
+        self._arch = arch_name
+        if arch_name:
+            self._args.append('-march=' + arch_name)
+        dev_version = platform_info.get('version', '')
+        arch_str = f' arch {arch_name}' if arch_name else ''
+        self._verbose(
+            f'device v{dev_version} mpy v{dev_ver}.{dev_sub}{arch_str},'
+            f' mpy-cross {cross_str}', 2)
+        self.active = True
+
+    def compile(self, src_path):
+        """Compile .py file to .mpy, return cache path or None
+
+        Skips boot.py, main.py, and non-.py files.
+        Uses cache if fresh (mtime check).
+        """
+        basename = _os.path.basename(src_path)
+        if basename in _BOOT_FILES:
+            self._verbose(f'mpy: skip {basename} (boot file)', 2)
+            return None
+        if not basename.endswith('.py'):
+            return None
+        stem = basename[:-3]
+        ver, sub = self._ver
+        arch_suffix = f'-{self._arch}' if self._arch else ''
+        cache_dir = _os.path.join(_os.path.dirname(src_path), '__pycache__')
+        cache_path = _os.path.join(
+            cache_dir, f'{stem}.mpy-{ver}.{sub}{arch_suffix}.mpy')
+        # Check if cache is fresh
+        if _os.path.exists(cache_path):
+            if _os.path.getmtime(cache_path) >= _os.path.getmtime(src_path):
+                self.compiled[src_path] = cache_path
+                return cache_path
+        # Compile
+        _os.makedirs(cache_dir, exist_ok=True)
+        cmd = ['mpy-cross'] + self._args + ['-o', cache_path, src_path]
+        self._log.warning('$ %s', ' '.join(cmd))
+        result = _subprocess.run(
+            cmd, capture_output=True, text=True, timeout=30)
+        if result.returncode != 0:
+            err = (result.stderr or result.stdout).strip()
+            self._log.warning(f'mpy-cross failed for {basename}: {err}')
+            return None
+        self.compiled[src_path] = cache_path
+        return cache_path
+
+    def compile_sources(self, sources, is_excluded=None):
+        """Pre-compile all .py source files to .mpy cache
+
+        Arguments:
+            sources: list of source paths (files or directories)
+            is_excluded: optional callback(name) -> bool for exclusion check
+        """
+        for src in sources:
+            if src.startswith(':'):
+                continue
+            src_path = src.rstrip('/')
+            if _os.path.isfile(src_path):
+                self.compile(src_path)
+            elif _os.path.isdir(src_path):
+                for root, dirs, files in _os.walk(src_path, topdown=True):
+                    if is_excluded:
+                        dirs[:] = sorted(
+                            d for d in dirs if not is_excluded(d))
+                    else:
+                        dirs.sort()
+                    for f in sorted(files):
+                        if f.endswith('.py'):
+                            self.compile(_os.path.join(root, f))

{mpytool-2.2.3 → mpytool-2.2.4}/mpytool/mpytool.py

@@ -12,6 +12,7 @@ import mpytool as _mpytool
 import mpytool.terminal as _terminal
 import mpytool.utils as _utils
 from mpytool.logger import SimpleColorLogger
+from mpytool.mpy_cross import MpyCross
 
 try:
     _about = _metadata.metadata("mpytool")
@@ -67,7 +68,7 @@ class MpyTool():
         self._conn = conn
         self._log = log if log is not None else SimpleColorLogger()
         self._verbose_out = verbose  # None = no verbose output (API mode)
-        self._exclude_dirs = {'.*', '*.pyc'}
+        self._exclude_dirs = {'.*', '*.pyc', '__pycache__'}
         if exclude_dirs:
             self._exclude_dirs.update(exclude_dirs)
         self._mpy = _mpytool.Mpy(conn, log=self._log, chunk_size=chunk_size)
@@ -87,6 +88,9 @@ class MpyTool():
         self._stats_wire_bytes = 0  # Actual bytes sent over wire (with encoding)
         self._stats_transferred_files = 0
         self._stats_start_time = None
+        # mpy-cross compilation
+        self._mpy_cross = False  # --mpy flag active
+        self._mpy_compiler = MpyCross(self._log, self.verbose)
         # Remote file info cache for batch operations
         self._remote_file_cache = {}  # {path: (size, hash) or None}
 
@@ -281,7 +285,12 @@ class MpyTool():
             basename = _os.path.basename(src_path)
             if basename and not _os.path.basename(dst_path):
                 dst_path = _join_remote_path(dst_path, basename)
-            files[dst_path] = _os.path.getsize(src_path)
+            cache = self._mpy_compiler.compiled.get(src_path)
+            if cache:
+                dst_path = dst_path[:-3] + '.mpy'
+                files[dst_path] = _os.path.getsize(cache)
+            else:
+                files[dst_path] = _os.path.getsize(src_path)
         elif _os.path.isdir(src_path):
             # For directories, mimic _put_dir behavior
             if add_src_basename:
@@ -296,9 +305,16 @@ class MpyTool():
                     rel_path = ''
                 for file_name in filenames:
                     spath = _os.path.join(root, file_name)
-                    dpath = _join_remote_path(
-                        _join_remote_path(dst_path, rel_path), file_name)
-                    files[dpath] = _os.path.getsize(spath)
+                    cache = self._mpy_compiler.compiled.get(spath)
+                    if cache:
+                        dst_name = file_name[:-3] + '.mpy'
+                        dpath = _join_remote_path(
+                            _join_remote_path(dst_path, rel_path), dst_name)
+                        files[dpath] = _os.path.getsize(cache)
+                    else:
+                        dpath = _join_remote_path(
+                            _join_remote_path(dst_path, rel_path), file_name)
+                        files[dpath] = _os.path.getsize(spath)
         return files
 
     def _file_needs_update(self, local_data, remote_path):
@@ -539,6 +555,13 @@ class MpyTool():
 
     def _upload_file(self, data, src_path, dst_path, show_progress):
         """Upload file data to device with stats tracking and progress display"""
+        # Use compiled .mpy data if available
+        cache = self._mpy_compiler.compiled.get(src_path)
+        if cache:
+            with open(cache, 'rb') as f:
+                data = f.read()
+            if dst_path.endswith('.py'):
+                dst_path = dst_path[:-3] + '.mpy'
         file_size = len(data)
         self._stats_total_bytes += file_size
         if show_progress and self._verbose >= 1:
@@ -750,28 +773,33 @@ class MpyTool():
 
     def cmd_cp(self, *args):
         """Copy files between local and device"""
-        # Parse flags: -f/--force, -z/--compress, -Z/--no-compress
+        # Parse flags: -f/--force, -m/--mpy, -z/--compress, -Z/--no-compress
         args = list(args)
         force = None
+        mpy_cross = None
         compress = None  # None = use global setting
         filtered_args = []
         for a in args:
             if a == '--force':
                 force = True
+            elif a == '--mpy':
+                mpy_cross = True
             elif a == '--compress':
                 compress = True
             elif a == '--no-compress':
                 compress = False
             elif a.startswith('-') and not a.startswith('--') and len(a) > 1:
-                # Handle combined short flags like -fz, -fZ
+                # Handle combined short flags like -fmz, -fZ
                 flags = a[1:]
                 if 'f' in flags:
                     force = True
+                if 'm' in flags:
+                    mpy_cross = True
                 if 'z' in flags:
                     compress = True
                 if 'Z' in flags:
                     compress = False
-                remaining = flags.replace('f', '').replace('z', '').replace('Z', '')
+                remaining = flags.replace('f', '').replace('m', '').replace('z', '').replace('Z', '')
                 if remaining:
                     filtered_args.append('-' + remaining)
             else:
@@ -782,8 +810,11 @@ class MpyTool():
         # Save and set flags for this command
         saved_force = self._force
         saved_compress = self._compress
+        saved_mpy_cross = self._mpy_cross
         if force is not None:
             self._force = force
+        if mpy_cross is not None:
+            self._mpy_cross = mpy_cross
         if compress is not None:
             self._compress = compress
         try:
@@ -791,12 +822,19 @@ class MpyTool():
         finally:
             self._force = saved_force
             self._compress = saved_compress
+            self._mpy_cross = saved_mpy_cross
 
     def _cmd_cp_impl(self, args):
         sources = list(args[:-1])
         dest = args[-1]
         dest_is_remote = dest.startswith(':')
         dest_path = dest[1:] if dest_is_remote else dest
+        # Initialize mpy-cross compilation if requested
+        if self._mpy_cross:
+            self._mpy_compiler.init(self._mpy.platform())
+            if self._mpy_compiler.active:
+                self._mpy_compiler.compile_sources(
+                    sources, self._is_excluded)
         # Determine if destination is a directory:
         # - Remote: '' (CWD) or '/' (root) or ends with '/'
         # - Local: ends with '/' or exists as directory
@@ -1421,7 +1459,7 @@ 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)
+  cp [-f] [-m] {src} [...] {dst} copy files (-f force, -m compile .mpy)
   mv {:src} [...] {:dst}        move/rename on device
   mkdir {:path} [...]           create directory (with parents)
   rm {:path} [...]              delete file/dir (:path/ = contents only)

{mpytool-2.2.3 → mpytool-2.2.4}/mpytool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpytool
-Version: 2.2.3
+Version: 2.2.4
 Summary: MPY tool - manage files on devices running MicroPython
 Author-email: Pavel Revak <pavel.revak@gmail.com>
 License-Expression: MIT
@@ -103,6 +103,7 @@ $ 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
+$ mpytool cp -m myapp :/            # compile .py to .mpy via mpy-cross
 ```
 
 Path semantics: `:` = device CWD, `:/` = device root. Trailing `/` on source = copy contents only.
@@ -114,11 +115,20 @@ Use `-f` or `--force` to upload all files regardless.
 $ mpytool cp -z main.py :/           # force compression (auto-detected by default)
 $ mpytool cp --no-compress data.bin :/  # disable compression
 $ mpytool -c 8K cp main.py :/        # set chunk size (512, 1K, 2K, 4K, 8K, 16K, 32K)
+$ mpytool cp -m myapp :/             # compile .py to .mpy before upload
+$ mpytool cp -fm myapp :/            # force upload + compile .mpy
 ```
 
 Compression is auto-detected based on device RAM and deflate module availability.
 Chunk size is auto-detected based on free RAM (larger chunks = faster transfer).
 
+The `-m`/`--mpy` flag compiles `.py` files to `.mpy` bytecode using `mpy-cross` before upload.
+Compiled files are cached in `__pycache__/` (recompiled only when source changes).
+`boot.py` and `main.py` are always uploaded as `.py` (firmware requirement).
+Requires `mpy-cross` in PATH (`pip install mpy-cross`). If mpy-cross version differs
+from device, automatically uses `-b` flag to target the correct bytecode version.
+If `mpy-cross` is not found, falls back to uploading `.py` with a warning.
+
 ### Move/rename on device
 ```
 $ mpytool mv :/old.py :/new.py      # rename file

{mpytool-2.2.3 → mpytool-2.2.4}/mpytool.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ mpytool/conn_socket.py
 mpytool/logger.py
 mpytool/mpy.py
 mpytool/mpy_comm.py
+mpytool/mpy_cross.py
 mpytool/mpytool.py
 mpytool/speedtest.py
 mpytool/terminal.py

{mpytool-2.2.3 → mpytool-2.2.4}/pyproject.toml

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

{mpytool-2.2.3 → mpytool-2.2.4}/tests/test_mpytool.py

@@ -1099,5 +1099,259 @@ class TestRunCommand(unittest.TestCase):
         self.tool._mpy.comm.try_raw_paste.assert_called_once()
 
 
+class TestMpyCompilation(unittest.TestCase):
+    """Tests for --mpy compilation feature (MpyCross class + MpyTool integration)"""
+
+    def setUp(self):
+        self.mock_conn = Mock()
+        self.tool = MpyTool(self.mock_conn, verbose=None)
+        self.tool._mpy = Mock()
+        self.compiler = self.tool._mpy_compiler
+        self.temp_dir = tempfile.mkdtemp()
+        # Create test .py files
+        self.script_py = os.path.join(self.temp_dir, 'script.py')
+        with open(self.script_py, 'w') as f:
+            f.write('print("hello")\n')
+        self.boot_py = os.path.join(self.temp_dir, 'boot.py')
+        with open(self.boot_py, 'w') as f:
+            f.write('# boot\n')
+        self.main_py = os.path.join(self.temp_dir, 'main.py')
+        with open(self.main_py, 'w') as f:
+            f.write('# main\n')
+        self.data_json = os.path.join(self.temp_dir, 'data.json')
+        with open(self.data_json, 'w') as f:
+            f.write('{}')
+        # Subdirectory with .py file
+        self.sub_dir = os.path.join(self.temp_dir, 'lib')
+        os.makedirs(self.sub_dir)
+        self.lib_py = os.path.join(self.sub_dir, 'mylib.py')
+        with open(self.lib_py, 'w') as f:
+            f.write('x = 1\n')
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    def _setup_compiler(self, arch=None):
+        """Setup compiler with active state and fake version"""
+        self.compiler.active = True
+        self.compiler._ver = (6, 3)
+        self.compiler._arch = arch
+        self.compiler._args = []
+
+    def test_compile_skip_boot_py(self):
+        """boot.py should not be compiled"""
+        self._setup_compiler()
+        result = self.compiler.compile(self.boot_py)
+        self.assertIsNone(result)
+        self.assertNotIn(self.boot_py, self.compiler.compiled)
+
+    def test_compile_skip_main_py(self):
+        """main.py should not be compiled"""
+        self._setup_compiler()
+        result = self.compiler.compile(self.main_py)
+        self.assertIsNone(result)
+        self.assertNotIn(self.main_py, self.compiler.compiled)
+
+    def test_compile_skip_non_py(self):
+        """Non-.py files should not be compiled"""
+        self._setup_compiler()
+        result = self.compiler.compile(self.data_json)
+        self.assertIsNone(result)
+
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_compile_creates_cache(self, mock_run):
+        """Compilation creates __pycache__/name.mpy-X.Y.mpy"""
+        self._setup_compiler()
+        mock_run.return_value = Mock(returncode=0, stderr='', stdout='')
+        result = self.compiler.compile(self.script_py)
+        expected_cache = os.path.join(
+            self.temp_dir, '__pycache__', 'script.mpy-6.3.mpy')
+        self.assertEqual(result, expected_cache)
+        self.assertEqual(self.compiler.compiled[self.script_py], expected_cache)
+        mock_run.assert_called_once_with(
+            ['mpy-cross', '-o', expected_cache, self.script_py],
+            capture_output=True, text=True, timeout=30)
+
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_compile_cache_includes_arch(self, mock_run):
+        """Cache path includes architecture for native/viper support"""
+        self._setup_compiler(arch='xtensawin')
+        self.compiler._args = ['-march=xtensawin']
+        mock_run.return_value = Mock(returncode=0, stderr='', stdout='')
+        result = self.compiler.compile(self.script_py)
+        expected_cache = os.path.join(
+            self.temp_dir, '__pycache__', 'script.mpy-6.3-xtensawin.mpy')
+        self.assertEqual(result, expected_cache)
+        mock_run.assert_called_once_with(
+            ['mpy-cross', '-march=xtensawin', '-o',
+                expected_cache, self.script_py],
+            capture_output=True, text=True, timeout=30)
+
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_compile_uses_b_flag_on_mismatch(self, mock_run):
+        """Compilation uses -b flag when mpy-cross version differs from device"""
+        self._setup_compiler()
+        self.compiler._args = ['-b', '6.1']
+        self.compiler._ver = (6, 1)
+        mock_run.return_value = Mock(returncode=0, stderr='', stdout='')
+        cache_path = os.path.join(
+            self.temp_dir, '__pycache__', 'script.mpy-6.1.mpy')
+        self.compiler.compile(self.script_py)
+        mock_run.assert_called_once_with(
+            ['mpy-cross', '-b', '6.1', '-o', cache_path, self.script_py],
+            capture_output=True, text=True, timeout=30)
+
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_compile_uses_cache_when_fresh(self, mock_run):
+        """Fresh cache file should be reused without recompilation"""
+        self._setup_compiler()
+        cache_dir = os.path.join(self.temp_dir, '__pycache__')
+        os.makedirs(cache_dir)
+        cache_path = os.path.join(cache_dir, 'script.mpy-6.3.mpy')
+        with open(cache_path, 'wb') as f:
+            f.write(b'\x4d\x06\x03')
+        import time
+        future = time.time() + 10
+        os.utime(cache_path, (future, future))
+        result = self.compiler.compile(self.script_py)
+        self.assertEqual(result, cache_path)
+        mock_run.assert_not_called()
+
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_compile_recompiles_stale_cache(self, mock_run):
+        """Stale cache file should trigger recompilation"""
+        self._setup_compiler()
+        cache_dir = os.path.join(self.temp_dir, '__pycache__')
+        os.makedirs(cache_dir)
+        cache_path = os.path.join(cache_dir, 'script.mpy-6.3.mpy')
+        with open(cache_path, 'wb') as f:
+            f.write(b'\x4d\x06\x03')
+        import time
+        future = time.time() + 10
+        os.utime(self.script_py, (future, future))
+        mock_run.return_value = Mock(returncode=0, stderr='', stdout='')
+        result = self.compiler.compile(self.script_py)
+        self.assertEqual(result, cache_path)
+        mock_run.assert_called_once()
+
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_compile_failure_returns_none(self, mock_run):
+        """mpy-cross failure should return None (upload .py instead)"""
+        self._setup_compiler()
+        self.compiler._log = Mock()
+        mock_run.return_value = Mock(
+            returncode=1, stderr='SyntaxError: invalid syntax', stdout='')
+        result = self.compiler.compile(self.script_py)
+        self.assertIsNone(result)
+        self.assertNotIn(self.script_py, self.compiler.compiled)
+
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_compile_sources_walks_directory(self, mock_run):
+        """compile_sources should compile all .py in directory"""
+        self._setup_compiler()
+        mock_run.return_value = Mock(returncode=0, stderr='', stdout='')
+        self.compiler.compile_sources(
+            [self.temp_dir], self.tool._is_excluded)
+        compiled_basenames = {
+            os.path.basename(p) for p in self.compiler.compiled}
+        self.assertIn('script.py', compiled_basenames)
+        self.assertIn('mylib.py', compiled_basenames)
+        self.assertNotIn('boot.py', compiled_basenames)
+        self.assertNotIn('main.py', compiled_basenames)
+
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_collect_dst_files_with_mpy(self, mock_run):
+        """_collect_dst_files should use .mpy paths and compiled sizes"""
+        self._setup_compiler()
+        mock_run.return_value = Mock(returncode=0, stderr='', stdout='')
+        self.compiler.compile_sources(
+            [self.temp_dir], self.tool._is_excluded)
+        # Create fake cache files with known sizes
+        for src, cache in self.compiler.compiled.items():
+            os.makedirs(os.path.dirname(cache), exist_ok=True)
+            with open(cache, 'wb') as f:
+                f.write(b'\x00' * 42)
+        files = self.tool._collect_dst_files(self.temp_dir, '/', add_src_basename=False)
+        py_paths = [p for p in files if p.endswith('.py')]
+        mpy_paths = [p for p in files if p.endswith('.mpy')]
+        self.assertEqual(
+            sorted(py_paths), sorted(['/boot.py', '/main.py']))
+        self.assertEqual(
+            sorted(mpy_paths), sorted(['/lib/mylib.mpy', '/script.mpy']))
+        for p in mpy_paths:
+            self.assertEqual(files[p], 42)
+
+    def test_upload_file_uses_compiled_data(self):
+        """_upload_file should use compiled data when available"""
+        self._setup_compiler()
+        cache_dir = os.path.join(self.temp_dir, '__pycache__')
+        os.makedirs(cache_dir)
+        cache_path = os.path.join(cache_dir, 'script.mpy-6.3.mpy')
+        compiled_data = b'\x4d\x06\x03compiled'
+        with open(cache_path, 'wb') as f:
+            f.write(compiled_data)
+        self.compiler.compiled[self.script_py] = cache_path
+        self.tool._mpy.put.return_value = (set(), 0)
+        self.tool._force = True
+        self.tool._upload_file(
+            b'original .py data', self.script_py, '/script.py', False)
+        call_args = self.tool._mpy.put.call_args
+        self.assertEqual(call_args[0][0], compiled_data)
+        self.assertEqual(call_args[0][1], '/script.mpy')
+
+    @patch('mpytool.mpy_cross._shutil.which', return_value='/usr/bin/mpy-cross')
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_init_version_match(self, mock_run, mock_which):
+        """init should succeed when versions match"""
+        mock_run.return_value = Mock(
+            returncode=0,
+            stdout='MicroPython v1.24.0 on 2024-10-01; mpy-cross emitting mpy v6.3\n',
+            stderr='')
+        self.compiler.init({
+            'mpy_ver': 6, 'mpy_sub': 3, 'mpy_arch': 4,
+            'version': '1.24.0'})
+        self.assertTrue(self.compiler.active)
+        self.assertEqual(self.compiler._ver, (6, 3))
+        self.assertIn('-march=armv6m', self.compiler._args)
+
+    @patch('mpytool.mpy_cross._shutil.which', return_value='/usr/bin/mpy-cross')
+    @patch('mpytool.mpy_cross._subprocess.run')
+    def test_init_version_mismatch_uses_b_flag(self, mock_run, mock_which):
+        """init should use -b flag on version mismatch"""
+        mock_run.return_value = Mock(
+            returncode=0,
+            stdout='MicroPython v1.24.0; mpy-cross emitting mpy v6.3\n',
+            stderr='')
+        self.compiler.init({
+            'mpy_ver': 6, 'mpy_sub': 1, 'mpy_arch': 10,
+            'version': '1.20.0'})
+        self.assertTrue(self.compiler.active)
+        self.assertEqual(self.compiler._ver, (6, 1))
+        self.assertIn('-b', self.compiler._args)
+        self.assertIn('6.1', self.compiler._args)
+        self.assertIn('-march=xtensawin', self.compiler._args)
+
+    @patch('mpytool.mpy_cross._shutil.which', return_value=None)
+    def test_init_not_found(self, mock_which):
+        """init should deactivate when mpy-cross not in PATH"""
+        self.compiler._log = Mock()
+        self.compiler.init({'mpy_ver': 6, 'mpy_sub': 3, 'version': '1.24.0'})
+        self.assertFalse(self.compiler.active)
+
+    def test_cmd_cp_mpy_flag_parsing(self):
+        """cmd_cp should parse --mpy and -m flags"""
+        self.tool._mpy_cross = False
+        self.tool._cmd_cp_impl = Mock()
+        self.tool.cmd_cp('--mpy', 'src', ':dst')
+        self.assertTrue(self.tool._mpy_cross or
+                        self.tool._cmd_cp_impl.called)
+
+    def test_cmd_cp_combined_flags(self):
+        """cmd_cp should parse combined flags like -fm"""
+        self.tool._cmd_cp_impl = Mock()
+        self.tool.cmd_cp('-fm', 'src', ':dst')
+        # After cmd_cp finishes (even with mock), flags should be restored
+
+
 if __name__ == "__main__":
     unittest.main()