mpflash 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

mpflash/mpremoteboard/mpy_fw_info.py

@@ -1,141 +1,141 @@
-# %%micropython
-import os
-import sys
-
-
-def _build(s):
-    # extract build from sys.version or os.uname().version if available
-    # sys.version: 'MicroPython v1.23.0-preview.6.g3d0b6276f'
-    # sys.implementation.version: 'v1.13-103-gb137d064e'
-    if not s:
-        return ""
-    s = s.split(" on ", 1)[0] if " on " in s else s
-    if s.startswith("v"):
-        if not "-" in s:
-            return ""
-        b = s.split("-")[1]
-        return b
-    if not "-preview" in s:
-        return ""
-    b = s.split("-preview")[1].split(".")[1]
-    return b
-
-
-def _version_str(version: tuple):  #  -> str:
-    v_str = ".".join([str(n) for n in version[:3]])
-    if len(version) > 3 and version[3]:
-        v_str += "-" + version[3]
-    return v_str
-
-
-def _info():  # type:() -> dict[str, str]
-    # sourcery skip: use-contextlib-suppress, use-fstring-for-formatting, use-named-expression
-    info = dict(
-        {
-            "family": sys.implementation[0],  # type: ignore
-            "version": "",
-            "build": "",
-            "ver": "",
-            "port": "stm32" if sys.platform.startswith("pyb") else sys.platform,  # port: esp32 / win32 / linux / stm32
-            "board": "GENERIC",
-            "cpu": "",
-            "mpy": "",
-            "arch": "",
-        }
-    )
-    try:
-        info["version"] = _version_str(sys.implementation.version)
-    except AttributeError:
-        pass
-    try:
-        machine = sys.implementation._machine if "_machine" in dir(sys.implementation) else os.uname().machine
-        info["board"] = machine.strip()
-        info["cpu"] = machine.split("with")[-1].strip() if "with" in machine else ""
-        info["mpy"] = (
-            sys.implementation._mpy
-            if "_mpy" in dir(sys.implementation)
-            else sys.implementation.mpy if "mpy" in dir(sys.implementation) else ""
-        )
-    except (AttributeError, IndexError):
-        pass
-
-    try:
-        if hasattr(sys, "version"):
-            info["build"] = _build(sys.version)
-        elif hasattr(os, "uname"):
-            info["build"] = _build(os.uname()[3])
-            if not info["build"]:
-                # extract build from uname().release if available
-                info["build"] = _build(os.uname()[2])
-    except (AttributeError, IndexError):
-        pass
-    # avoid  build hashes
-    if info["build"] and len(info["build"]) > 5:
-        info["build"] = ""
-
-    if info["version"] == "" and sys.platform not in ("unix", "win32"):
-        try:
-            u = os.uname()
-            info["version"] = u.release
-        except (IndexError, AttributeError, TypeError):
-            pass
-    # detect families
-    for fam_name, mod_name, mod_thing in [
-        ("pycopy", "pycopy", "const"),
-        ("pycom", "pycom", "FAT"),
-        ("ev3-pybricks", "pybricks.hubs", "EV3Brick"),
-    ]:
-        try:
-            _t = __import__(mod_name, None, None, (mod_thing))
-            info["family"] = fam_name
-            del _t
-            break
-        except (ImportError, KeyError):
-            pass
-
-    if info["family"] == "ev3-pybricks":
-        info["release"] = "2.0.0"
-
-    if info["family"] == "micropython":
-        if (
-            info["version"]
-            and info["version"].endswith(".0")
-            and info["version"] >= "1.10.0"  # versions from 1.10.0 to 1.20.0 do not have a micro .0
-            and info["version"] <= "1.19.9"
-        ):
-            # drop the .0 for newer releases
-            info["version"] = info["version"][:-2]
-
-    # spell-checker: disable
-    if "mpy" in info and info["mpy"]:  # mpy on some v1.11+ builds
-        sys_mpy = int(info["mpy"])
-        # .mpy architecture
-        arch = [
-            None,
-            "x86",
-            "x64",
-            "armv6",
-            "armv6m",
-            "armv7m",
-            "armv7em",
-            "armv7emsp",
-            "armv7emdp",
-            "xtensa",
-            "xtensawin",
-        ][sys_mpy >> 10]
-        if arch:
-            info["arch"] = arch
-        # .mpy version.minor
-        info["mpy"] = "v{}.{}".format(sys_mpy & 0xFF, sys_mpy >> 8 & 3)
-    # simple to use version[-build] string avoiding f-strings for backward compat
-    info["ver"] = (
-        "v{version}-{build}".format(version=info["version"], build=info["build"])
-        if info["build"]
-        else "v{version}".format(version=info["version"])
-    )
-
-    return info
-
-
-print(_info())
-del _info, _build, _version_str
+# %%micropython
+import os
+import sys
+
+
+def _build(s):
+    # extract build from sys.version or os.uname().version if available
+    # sys.version: 'MicroPython v1.23.0-preview.6.g3d0b6276f'
+    # sys.implementation.version: 'v1.13-103-gb137d064e'
+    if not s:
+        return ""
+    s = s.split(" on ", 1)[0] if " on " in s else s
+    if s.startswith("v"):
+        if not "-" in s:
+            return ""
+        b = s.split("-")[1]
+        return b
+    if not "-preview" in s:
+        return ""
+    b = s.split("-preview")[1].split(".")[1]
+    return b
+
+
+def _version_str(version: tuple):  #  -> str:
+    v_str = ".".join([str(n) for n in version[:3]])
+    if len(version) > 3 and version[3]:
+        v_str += "-" + version[3]
+    return v_str
+
+
+def _info():  # type:() -> dict[str, str]
+    # sourcery skip: use-contextlib-suppress, use-fstring-for-formatting, use-named-expression
+    info = dict(
+        {
+            "family": sys.implementation[0],  # type: ignore
+            "version": "",
+            "build": "",
+            "ver": "",
+            "port": "stm32" if sys.platform.startswith("pyb") else sys.platform,  # port: esp32 / win32 / linux / stm32
+            "board": "GENERIC",
+            "cpu": "",
+            "mpy": "",
+            "arch": "",
+        }
+    )
+    try:
+        info["version"] = _version_str(sys.implementation.version)
+    except AttributeError:
+        pass
+    try:
+        machine = sys.implementation._machine if "_machine" in dir(sys.implementation) else os.uname().machine
+        info["board"] = machine.strip()
+        info["cpu"] = machine.split("with")[-1].strip() if "with" in machine else ""
+        info["mpy"] = (
+            sys.implementation._mpy
+            if "_mpy" in dir(sys.implementation)
+            else sys.implementation.mpy if "mpy" in dir(sys.implementation) else ""
+        )
+    except (AttributeError, IndexError):
+        pass
+
+    try:
+        if hasattr(sys, "version"):
+            info["build"] = _build(sys.version)
+        elif hasattr(os, "uname"):
+            info["build"] = _build(os.uname()[3])
+            if not info["build"]:
+                # extract build from uname().release if available
+                info["build"] = _build(os.uname()[2])
+    except (AttributeError, IndexError):
+        pass
+    # avoid  build hashes
+    if info["build"] and len(info["build"]) > 5:
+        info["build"] = ""
+
+    if info["version"] == "" and sys.platform not in ("unix", "win32"):
+        try:
+            u = os.uname()
+            info["version"] = u.release
+        except (IndexError, AttributeError, TypeError):
+            pass
+    # detect families
+    for fam_name, mod_name, mod_thing in [
+        ("pycopy", "pycopy", "const"),
+        ("pycom", "pycom", "FAT"),
+        ("ev3-pybricks", "pybricks.hubs", "EV3Brick"),
+    ]:
+        try:
+            _t = __import__(mod_name, None, None, (mod_thing))
+            info["family"] = fam_name
+            del _t
+            break
+        except (ImportError, KeyError):
+            pass
+
+    if info["family"] == "ev3-pybricks":
+        info["release"] = "2.0.0"
+
+    if info["family"] == "micropython":
+        if (
+            info["version"]
+            and info["version"].endswith(".0")
+            and info["version"] >= "1.10.0"  # versions from 1.10.0 to 1.20.0 do not have a micro .0
+            and info["version"] <= "1.19.9"
+        ):
+            # drop the .0 for newer releases
+            info["version"] = info["version"][:-2]
+
+    # spell-checker: disable
+    if "mpy" in info and info["mpy"]:  # mpy on some v1.11+ builds
+        sys_mpy = int(info["mpy"])
+        # .mpy architecture
+        arch = [
+            None,
+            "x86",
+            "x64",
+            "armv6",
+            "armv6m",
+            "armv7m",
+            "armv7em",
+            "armv7emsp",
+            "armv7emdp",
+            "xtensa",
+            "xtensawin",
+        ][sys_mpy >> 10]
+        if arch:
+            info["arch"] = arch
+        # .mpy version.minor
+        info["mpy"] = "v{}.{}".format(sys_mpy & 0xFF, sys_mpy >> 8 & 3)
+    # simple to use version[-build] string avoiding f-strings for backward compat
+    info["ver"] = (
+        "v{version}-{build}".format(version=info["version"], build=info["build"])
+        if info["build"]
+        else "v{version}".format(version=info["version"])
+    )
+
+    return info
+
+
+print(_info())
+del _info, _build, _version_str

mpflash/mpremoteboard/runner.py

@@ -1,140 +1,140 @@
-"""
-Run a command and return the output and return code as a tuple
-"""
-
-import subprocess
-from dataclasses import dataclass
-from threading import Timer
-from typing import List, Optional, Tuple
-
-from loguru import logger as log
-
-LogTagList = List[str]
-
-
-@dataclass
-class LogTags:
-    reset_tags: LogTagList
-    error_tags: LogTagList
-    warning_tags: LogTagList
-    success_tags: LogTagList
-    ignore_tags: LogTagList
-
-
-DEFAULT_RESET_TAGS = [
-    # ESP32 reset causes
-    "rst cause:1, boot mode:",  # 1 -> hardware watch dog reset
-    "rst cause:2, boot mode:",  # 2 -> software watch dog reset (From an exception)
-    "rst cause:3, boot mode:",  # 3 -> software watch dog reset system_restart (Possibly unfed watchdog got angry)
-    "rst cause:4, boot mode:",  # 4 -> soft restart (Possibly with a restart command)
-    "boot.esp32: PRO CPU has been reset by WDT.",
-    "rst:0x10 (RTCWDT_RTC_RESET)",
-]
-
-
-def run(
-    cmd: List[str],
-    timeout: int = 60,
-    log_errors: bool = True,
-    no_info: bool = False,
-    *,
-    log_warnings: bool = False,
-    reset_tags: Optional[LogTagList] = None,
-    error_tags: Optional[LogTagList] = None,
-    warning_tags: Optional[LogTagList] = None,
-    success_tags: Optional[LogTagList] = None,
-    ignore_tags: Optional[LogTagList] = None,
-) -> Tuple[int, List[str]]:
-    # sourcery skip: no-long-functions
-    """
-    Run a command and return the output and return code as a tuple
-    Parameters
-    ----------
-    cmd : List[str]
-        The command to run
-    timeout : int, optional
-        The timeout in seconds, by default 60
-    log_errors : bool, optional
-        If False, don't log errors, Default: true
-    no_info : bool, optional
-        If True, don't log info, by default False
-    error_tags : Optional[LogTagList], optional
-        A list of strings to look for in the output to log as errors, by default None
-    warning_tags : Optional[LogTagList], optional
-        A list of strings to look for in the output to log as warnings, by default None
-    Returns
-    -------
-    Tuple[int, List[str]]
-        The return code and the output as a list of strings
-    """
-    if not reset_tags:
-        reset_tags = DEFAULT_RESET_TAGS
-    if not error_tags:
-        error_tags = ["Traceback ", "Error: ", "Exception: ", "ERROR :", "CRIT  :"]
-    if not warning_tags:
-        warning_tags = ["WARN  :", "TRACE :"]
-    if not success_tags:
-        success_tags = []
-    if not ignore_tags:
-        ignore_tags = ['  File "<stdin>",']
-
-    replace_tags = ["\x1b[1A"]
-
-    output = []
-    try:
-        proc = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            universal_newlines=True,
-            encoding="utf-8",
-        )
-    except FileNotFoundError as e:
-        raise FileNotFoundError(f"Failed to start {cmd[0]}") from e
-
-    def timed_out():
-        proc.kill()
-        if log_warnings:
-            log.warning(f"Command {cmd} timed out after {timeout} seconds")
-
-    timer = Timer(timeout, timed_out)
-    try:
-        timer.start()
-        # stdout has most of the output, assign log categories based on text tags
-        if proc.stdout:
-            for line in proc.stdout:
-                if not line or not line.strip():
-                    continue
-                for tag in replace_tags:
-                    line = line.replace(tag, "")
-                output.append(line)  # full output, no trimming
-                if any(tag in line for tag in reset_tags):
-                    raise RuntimeError("Board reset detected")
-
-                line = line.rstrip("\n")
-                # if any of the error tags in the line
-                if any(tag in line for tag in error_tags):
-                    if not log_errors:
-                        continue
-                    log.error(line)
-                elif any(tag in line for tag in warning_tags):
-                    log.warning(line)
-                elif any(tag in line for tag in success_tags):
-                    log.success(line)
-                elif any(tag in line for tag in ignore_tags):
-                    continue
-                else:
-                    if not no_info:
-                        if line.startswith(("INFO  : ", "WARN  : ", "ERROR : ")):
-                            line = line[8:].lstrip()
-                        log.info(line)
-        if proc.stderr and log_errors:
-            for line in proc.stderr:
-                log.warning(line)
-    except UnicodeDecodeError as e:
-        log.error(f"Failed to decode output: {e}")
-    finally:
-        timer.cancel()
-
-    proc.wait(timeout=1)
-    return proc.returncode or 0, output
+"""
+Run a command and return the output and return code as a tuple
+"""
+
+import subprocess
+from dataclasses import dataclass
+from threading import Timer
+from typing import List, Optional, Tuple
+
+from loguru import logger as log
+
+LogTagList = List[str]
+
+
+@dataclass
+class LogTags:
+    reset_tags: LogTagList
+    error_tags: LogTagList
+    warning_tags: LogTagList
+    success_tags: LogTagList
+    ignore_tags: LogTagList
+
+
+DEFAULT_RESET_TAGS = [
+    # ESP32 reset causes
+    "rst cause:1, boot mode:",  # 1 -> hardware watch dog reset
+    "rst cause:2, boot mode:",  # 2 -> software watch dog reset (From an exception)
+    "rst cause:3, boot mode:",  # 3 -> software watch dog reset system_restart (Possibly unfed watchdog got angry)
+    "rst cause:4, boot mode:",  # 4 -> soft restart (Possibly with a restart command)
+    "boot.esp32: PRO CPU has been reset by WDT.",
+    "rst:0x10 (RTCWDT_RTC_RESET)",
+]
+
+
+def run(
+    cmd: List[str],
+    timeout: int = 60,
+    log_errors: bool = True,
+    no_info: bool = False,
+    *,
+    log_warnings: bool = False,
+    reset_tags: Optional[LogTagList] = None,
+    error_tags: Optional[LogTagList] = None,
+    warning_tags: Optional[LogTagList] = None,
+    success_tags: Optional[LogTagList] = None,
+    ignore_tags: Optional[LogTagList] = None,
+) -> Tuple[int, List[str]]:
+    # sourcery skip: no-long-functions
+    """
+    Run a command and return the output and return code as a tuple
+    Parameters
+    ----------
+    cmd : List[str]
+        The command to run
+    timeout : int, optional
+        The timeout in seconds, by default 60
+    log_errors : bool, optional
+        If False, don't log errors, Default: true
+    no_info : bool, optional
+        If True, don't log info, by default False
+    error_tags : Optional[LogTagList], optional
+        A list of strings to look for in the output to log as errors, by default None
+    warning_tags : Optional[LogTagList], optional
+        A list of strings to look for in the output to log as warnings, by default None
+    Returns
+    -------
+    Tuple[int, List[str]]
+        The return code and the output as a list of strings
+    """
+    if not reset_tags:
+        reset_tags = DEFAULT_RESET_TAGS
+    if not error_tags:
+        error_tags = ["Traceback ", "Error: ", "Exception: ", "ERROR :", "CRIT  :"]
+    if not warning_tags:
+        warning_tags = ["WARN  :", "TRACE :"]
+    if not success_tags:
+        success_tags = []
+    if not ignore_tags:
+        ignore_tags = ['  File "<stdin>",']
+
+    replace_tags = ["\x1b[1A"]
+
+    output = []
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+            encoding="utf-8",
+        )
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"Failed to start {cmd[0]}") from e
+
+    def timed_out():
+        proc.kill()
+        if log_warnings:
+            log.warning(f"Command {cmd} timed out after {timeout} seconds")
+
+    timer = Timer(timeout, timed_out)
+    try:
+        timer.start()
+        # stdout has most of the output, assign log categories based on text tags
+        if proc.stdout:
+            for line in proc.stdout:
+                if not line or not line.strip():
+                    continue
+                for tag in replace_tags:
+                    line = line.replace(tag, "")
+                output.append(line)  # full output, no trimming
+                if any(tag in line for tag in reset_tags):
+                    raise RuntimeError("Board reset detected")
+
+                line = line.rstrip("\n")
+                # if any of the error tags in the line
+                if any(tag in line for tag in error_tags):
+                    if not log_errors:
+                        continue
+                    log.error(line)
+                elif any(tag in line for tag in warning_tags):
+                    log.warning(line)
+                elif any(tag in line for tag in success_tags):
+                    log.success(line)
+                elif any(tag in line for tag in ignore_tags):
+                    continue
+                else:
+                    if not no_info:
+                        if line.startswith(("INFO  : ", "WARN  : ", "ERROR : ")):
+                            line = line[8:].lstrip()
+                        log.info(line)
+        if proc.stderr and log_errors:
+            for line in proc.stderr:
+                log.warning(line)
+    except UnicodeDecodeError as e:
+        log.error(f"Failed to decode output: {e}")
+    finally:
+        timer.cancel()
+
+    proc.wait(timeout=1)
+    return proc.returncode or 0, output