micropython-stubber 1.20.4__py3-none-any.whl → 1.20.5__py3-none-any.whl

mpflash/mpflash/common.py

@@ -2,6 +2,7 @@ import fnmatch
 import os
 import sys
 from dataclasses import dataclass, field
+from enum import Enum
 from pathlib import Path
 from typing import List, Optional, Union
 
@@ -90,14 +91,26 @@ class DownloadParams(Params):
     force: bool = False
 
 
+class BootloaderMethod(Enum):
+    MANUAL = "manual"
+    MPY = "mpy"
+    TOUCH_1200 = "touch1200"
+    NONE = "none"
+
+
+
 @dataclass
 class FlashParams(Params):
     """Parameters for flashing a board"""
 
     erase: bool = True
-    bootloader: bool = True
+    bootloader: BootloaderMethod = BootloaderMethod.NONE
     cpu: str = ""
 
+    def __post_init__(self):
+        if isinstance(self.bootloader, str):
+            self.bootloader = BootloaderMethod(self.bootloader)
+
 
 ParamType = Union[DownloadParams, FlashParams]
 

mpflash/mpflash/config.py

@@ -1,11 +1,14 @@
 """centralized configuration for mpflash"""
 
+import os
 from pathlib import Path
 from typing import List
 
 import pkg_resources
 import platformdirs
 
+from mpflash.logger import log
+
 
 def get_version():
     name = __package__ or "mpflash"
@@ -21,10 +24,23 @@ class MPtoolConfig:
     quiet: bool = False
     verbose: bool = False
     ignore_ports: List[str] = []
-    interactive: bool = True
     firmware_folder: Path = platformdirs.user_downloads_path() / "firmware"
     # test options specified on the commandline
     tests: List[str] = []
+    _interactive: bool = True
+
+    @property
+    def interactive(self):
+        # No interactions in CI
+        if os.getenv('GITHUB_ACTIONS') == 'true':
+            log.warning("Disabling interactive mode in CI")
+            return False
+        return self._interactive
+    
+    @interactive.setter
+    def interactive(self, value:bool):
+        self._interactive = value
+
 
 
 config = MPtoolConfig()

mpflash/mpflash/download.py

@@ -19,7 +19,6 @@ from loguru import logger as log
 from rich.progress import track
 
 from mpflash.common import PORT_FWTYPES, FWInfo
-from mpflash.downloaded import clean_downloaded_firmwares
 from mpflash.errors import MPFlashError
 from mpflash.mpboard_id import get_known_ports
 from mpflash.vendor.versions import clean_version
@@ -246,8 +245,8 @@ def download_firmwares(
                 continue
             writer.write(board.to_dict())
             downloaded += 1
-    if downloaded > 0:
-        clean_downloaded_firmwares(firmware_folder)
+    # if downloaded > 0:
+    #     clean_downloaded_firmwares(firmware_folder)
     log.success(f"Downloaded {downloaded} firmwares, skipped {skipped} existing files.")
     return downloaded + skipped
 

mpflash/mpflash/downloaded.py

@@ -103,9 +103,9 @@ def filter_downloaded_fwlist(
         # never get a preview for an older version
         fw_list = [fw for fw in fw_list if fw.preview]
     else:
-        # FWInfo version has no v1.2.3 prefix
-        _version = {clean_version(version, drop_v=True), clean_version(version, drop_v=False)}
-        fw_list = [fw for fw in fw_list if fw.version in _version]
+        # older FWInfo version has no v1.2.3 prefix
+        either = [clean_version(version, drop_v=False), clean_version(version, drop_v=True)]
+        fw_list = [fw for fw in fw_list if fw.version in either]
     log.trace(f"Filtering firmware for {version} : {len(fw_list)} found.")
     # filter by port
     if port:

mpflash/mpflash/errors.py

@@ -2,4 +2,8 @@
 
 
 class MPFlashError(Exception):
-    pass
+    """Base class for exceptions in this module."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(message)

mpflash/mpflash/flash.py

@@ -1,10 +1,9 @@
-import time
 from pathlib import Path
 
 from loguru import logger as log
 
-from mpflash.common import PORT_FWTYPES
-from mpflash.mpremoteboard import MPRemoteBoard
+from mpflash.bootloader import enter_bootloader
+from mpflash.common import PORT_FWTYPES, BootloaderMethod
 
 from .flash_esp import flash_esp
 from .flash_stm32 import flash_stm32
@@ -14,13 +13,15 @@ from .worklist import WorkList
 # #########################################################################################################
 
 
+
 def flash_list(
     todo: WorkList,
     fw_folder: Path,
     erase: bool,
-    bootloader: bool,
+    bootloader: BootloaderMethod,
 ):
     """Flash a list of boards with the specified firmware."""
+    UF2_PORTS = [port for port, exts in PORT_FWTYPES.items() if ".uf2" in exts]
     flashed = []
     for mcu, fw_info in todo:
         fw_file = fw_folder / fw_info.filename
@@ -30,14 +31,13 @@ def flash_list(
         log.info(f"Updating {mcu.board} on {mcu.serialport} to {fw_info.version}")
         updated = None
         # try:
-        if mcu.port in [port for port, exts in PORT_FWTYPES.items() if ".uf2" in exts] and fw_file.suffix == ".uf2":
-            # any .uf2 port ["samd", "rp2", "nrf"]:
-            if bootloader:
-                enter_bootloader(mcu)
+        if mcu.port in UF2_PORTS and fw_file.suffix == ".uf2":
+            if not enter_bootloader(mcu, bootloader):
+                continue
             updated = flash_uf2(mcu, fw_file=fw_file, erase=erase)
         elif mcu.port in ["stm32"]:
-            if bootloader:
-                enter_bootloader(mcu)
+            if not enter_bootloader(mcu, bootloader):
+                continue
             updated = flash_stm32(mcu, fw_file, erase=erase)
         elif mcu.port in ["esp32", "esp8266"]:
             #  bootloader is handled by esptool for esp32/esp8266
@@ -50,20 +50,3 @@ def flash_list(
         else:
             log.error(f"Failed to flash {mcu.board} on {mcu.serialport}")
     return flashed
-
-
-def enter_bootloader(mcu: MPRemoteBoard, timeout: int = 10, wait_after: int = 2):
-    """Enter the bootloader mode for the board"""
-    log.info(f"Entering bootloader on {mcu.board} on {mcu.serialport}")
-    mcu.run_command("bootloader", timeout=timeout)
-    time.sleep(wait_after)
-
-
-# TODO:
-# flash from some sort of queue to allow different images to be flashed to the same board
-#  - flash variant 1
-#  - stub variant 1
-#  - flash variant 2
-#  - stub variant 2
-#
-# JIT download / download any missing firmwares based on the detected boards

mpflash/mpflash/flash_uf2_macos.py

@@ -3,15 +3,12 @@
 # sourcery skip: snake-case-functions
 from __future__ import annotations
 
-import sys
 import time
 from pathlib import Path
 from typing import Optional
 
-from loguru import logger as log
 from rich.progress import track
 
-from .flash_uf2_boardid import get_board_id
 
 
 def wait_for_UF2_macos(s_max: int = 10) -> Optional[Path]:

mpflash/mpflash/vendor/click_aliases.py

@@ -0,0 +1,91 @@
+# Copyright (c) 2016 Robbin Bonthond
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# ------------------------------------------------------------------------------------
+# modified to avoid conflcts with rich_click
+
+# sourcery skip: assign-if-exp, use-named-expression
+
+import rich_click as click
+
+_click7 = click.__version__[0] >= "7"
+
+
+class ClickAliasedGroup(click.RichGroup):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._commands = {}
+        self._aliases = {}
+
+    def add_command(self, *args, **kwargs):
+        aliases = kwargs.pop("aliases", [])
+        super().add_command(*args, **kwargs)
+        if aliases:
+            cmd = args[0]
+            name = args[1] if len(args) > 1 else None
+            name = name or cmd.name
+            if name is None:
+                raise TypeError("Command has no name.")
+
+            self._commands[name] = aliases
+            for alias in aliases:
+                self._aliases[alias] = cmd.name
+
+    def command(self, *args, **kwargs):
+        aliases = kwargs.pop("aliases", [])
+        decorator = super().command(*args, **kwargs)
+        if not aliases:
+            return decorator
+
+        def _decorator(f):
+            cmd = decorator(f)
+            if aliases:
+                self._commands[cmd.name] = aliases
+                for alias in aliases:
+                    self._aliases[alias] = cmd.name
+            return cmd
+
+        return _decorator
+
+    def group(self, *args, **kwargs):
+        aliases = kwargs.pop("aliases", [])
+        decorator = super().group(*args, **kwargs)
+        if not aliases:
+            return decorator
+
+        def _decorator(f):
+            cmd = decorator(f)
+            if aliases:
+                self._commands[cmd.name] = aliases
+                for alias in aliases:
+                    self._aliases[alias] = cmd.name
+            return cmd
+
+        return _decorator
+
+    def resolve_alias(self, cmd_name):
+        if cmd_name in self._aliases:
+            return self._aliases[cmd_name]
+        return cmd_name
+
+    def get_command(self, ctx, cmd_name):
+        cmd_name = self.resolve_alias(cmd_name)
+        command = super().get_command(ctx, cmd_name)
+        if command:
+            return command
+        return None
+
+    # def format_commands(self, ctx, formatter):
+    # TODO: output alias with commands - but that is a significant re-write
+    # for now add alias to help text
+
+
+# ------------------------------------------------------------------------------------