Add CI built packages from commit f505858 of update/ruff

Author: github-actions[bot]

mip/update/ruff/file/01/011649d0

@@ -0,0 +1,221 @@
+#! /usr/bin/env python3
+
+# Copyright 1994 by Lance Ellinghouse
+# Cathedral City, California Republic, United States of America.
+#                        All Rights Reserved
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted,
+# provided that the above copyright notice appear in all copies and that
+# both that copyright notice and this permission notice appear in
+# supporting documentation, and that the name of Lance Ellinghouse
+# not be used in advertising or publicity pertaining to distribution
+# of the software without specific, written prior permission.
+# LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
+# THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE
+# FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+# Modified by Jack Jansen, CWI, July 1995:
+# - Use binascii module to do the actual line-by-line conversion
+#   between ascii and binary. This results in a 1000-fold speedup. The C
+#   version is still 5 times faster, though.
+# - Arguments more compliant with python standard
+
+"""Implementation of the UUencode and UUdecode functions.
+
+encode(in_file, out_file [,name, mode])
+decode(in_file [, out_file, mode])
+"""
+
+import binascii
+import os
+import sys
+
+__all__ = ["Error", "encode", "decode"]
+
+
+class Error(Exception):
+    pass
+
+
+def encode(in_file, out_file, name=None, mode=None):
+    """Uuencode file"""
+    #
+    # If in_file is a pathname open it and change defaults
+    #
+    opened_files = []
+    try:
+        if in_file == "-":
+            in_file = sys.stdin.buffer
+        elif isinstance(in_file, str):
+            if name is None:
+                name = os.path.basename(in_file)
+            if mode is None:
+                try:
+                    mode = os.stat(in_file).st_mode
+                except AttributeError:
+                    pass
+            in_file = open(in_file, "rb")
+            opened_files.append(in_file)
+        #
+        # Open out_file if it is a pathname
+        #
+        if out_file == "-":
+            out_file = sys.stdout.buffer
+        elif isinstance(out_file, str):
+            out_file = open(out_file, "wb")
+            opened_files.append(out_file)
+        #
+        # Set defaults for name and mode
+        #
+        if name is None:
+            name = "-"
+        if mode is None:
+            mode = 0o666
+        #
+        # Write the data
+        #
+        out_file.write(("begin %o %s\n" % ((mode & 0o777), name)).encode("ascii"))
+        data = in_file.read(45)
+        while len(data) > 0:
+            out_file.write(binascii.b2a_uu(data))
+            data = in_file.read(45)
+        out_file.write(b" \nend\n")
+    finally:
+        for f in opened_files:
+            f.close()
+
+
+def decode(in_file, out_file=None, mode=None, quiet=False):
+    """Decode uuencoded file"""
+    #
+    # Open the input file, if needed.
+    #
+    opened_files = []
+    if in_file == "-":
+        in_file = sys.stdin.buffer
+    elif isinstance(in_file, str):
+        in_file = open(in_file, "rb")
+        opened_files.append(in_file)
+
+    try:
+        #
+        # Read until a begin is encountered or we've exhausted the file
+        #
+        while True:
+            hdr = in_file.readline()
+            if not hdr:
+                raise Error("No valid begin line found in input file")
+            if not hdr.startswith(b"begin"):
+                continue
+            hdrfields = hdr.split(b" ", 2)
+            if len(hdrfields) == 3 and hdrfields[0] == b"begin":
+                try:
+                    int(hdrfields[1], 8)
+                    break
+                except ValueError:
+                    pass
+        if out_file is None:
+            # If the filename isn't ASCII, what's up with that?!?
+            out_file = hdrfields[2].rstrip(b" \t\r\n\f").decode("ascii")
+            if os.path.exists(out_file):
+                raise Error("Cannot overwrite existing file: %s" % out_file)
+        if mode is None:
+            mode = int(hdrfields[1], 8)
+        #
+        # Open the output file
+        #
+        if out_file == "-":
+            out_file = sys.stdout.buffer
+        elif isinstance(out_file, str):
+            fp = open(out_file, "wb")
+            try:
+                os.path.chmod(out_file, mode)
+            except AttributeError:
+                pass
+            out_file = fp
+            opened_files.append(out_file)
+        #
+        # Main decoding loop
+        #
+        s = in_file.readline()
+        while s and s.strip(b" \t\r\n\f") != b"end":
+            try:
+                data = binascii.a2b_uu(s)
+            except binascii.Error as v:
+                # Workaround for broken uuencoders by /Fredrik Lundh
+                nbytes = (((s[0] - 32) & 63) * 4 + 5) // 3
+                data = binascii.a2b_uu(s[:nbytes])
+                if not quiet:
+                    sys.stderr.write("Warning: %s\n" % v)
+            out_file.write(data)
+            s = in_file.readline()
+        if not s:
+            raise Error("Truncated input file")
+    finally:
+        for f in opened_files:
+            f.close()
+
+
+def test():
+    """uuencode/uudecode main program"""
+
+    import optparse
+
+    parser = optparse.OptionParser(usage="usage: %prog [-d] [-t] [input [output]]")
+    parser.add_option(
+        "-d",
+        "--decode",
+        dest="decode",
+        help="Decode (instead of encode)?",
+        default=False,
+        action="store_true",
+    )
+    parser.add_option(
+        "-t",
+        "--text",
+        dest="text",
+        help="data is text, encoded format unix-compatible text?",
+        default=False,
+        action="store_true",
+    )
+
+    (options, args) = parser.parse_args()
+    if len(args) > 2:
+        parser.error("incorrect number of arguments")
+        sys.exit(1)
+
+    # Use the binary streams underlying stdin/stdout
+    input = sys.stdin.buffer
+    output = sys.stdout.buffer
+    if len(args) > 0:
+        input = args[0]
+    if len(args) > 1:
+        output = args[1]
+
+    if options.decode:
+        if options.text:
+            if isinstance(output, str):
+                output = open(output, "wb")
+            else:
+                print(sys.argv[0], ": cannot do -t to stdout")
+                sys.exit(1)
+        decode(input, output)
+    else:
+        if options.text:
+            if isinstance(input, str):
+                input = open(input, "rb")
+            else:
+                print(sys.argv[0], ": cannot do -t from stdin")
+                sys.exit(1)
+        encode(input, output)
+
+
+if __name__ == "__main__":
+    test()
+
+
+__version__ = '0.5.1'

mip/update/ruff/file/01/018bf3cb

@@ -0,0 +1,139 @@
+# MicroPython LoRa STM32WL55 embedded sub-ghz radio driver
+# MIT license; Copyright (c) 2022 Angus Gratton
+#
+# This driver is essentially an embedded SX1262 with a custom internal interface block.
+# Requires the stm module in MicroPython to be compiled with STM32WL5 subghz radio support.
+#
+# LoRa is a registered trademark or service mark of Semtech Corporation or its affiliates.
+from machine import Pin, SPI
+import stm
+from . import sx126x
+from micropython import const
+
+_CMD_CLR_ERRORS = const(0x07)
+
+_REG_OCP = const(0x8E7)
+
+# Default antenna switch config is as per Nucleo WL-55 board. See UM2592 Fig 18.
+# Possible to work with other antenna switch board configurations by passing
+# different ant_sw_class arguments to the modem, any class that creates an object with rx/tx
+
+
+class NucleoWL55RFConfig:
+    def __init__(self):
+        self._FE_CTRL = (Pin(x, mode=Pin.OUT) for x in ("C4", "C5", "C3"))
+
+    def _set_fe_ctrl(self, values):
+        for pin, val in zip(self._FE_CTRL, values):
+            pin(val)
+
+    def rx(self):
+        self._set_fe_ctrl((1, 0, 1))
+
+    def tx(self, hp):
+        self._set_fe_ctrl((0 if hp else 1, 1, 1))
+
+    def idle(self):
+        pass
+
+
+class DIO1:
+    # Dummy DIO1 "Pin" wrapper class to pass to the _SX126x class
+    def irq(self, handler, _):
+        stm.subghz_irq(handler)
+
+
+class _WL55SubGhzModem(sx126x._SX126x):
+    # Don't construct this directly, construct lora.WL55SubGhzModem or lora.AsyncWL55SubGHzModem
+    def __init__(
+        self,
+        lora_cfg=None,
+        tcxo_millivolts=1700,
+        ant_sw=NucleoWL55RFConfig,
+    ):
+        self._hp = False
+
+        if ant_sw == NucleoWL55RFConfig:
+            # To avoid the default argument being an object instance
+            ant_sw = NucleoWL55RFConfig()
+
+        super().__init__(
+            # RM0453 7.2.13 says max 16MHz, but this seems more stable
+            SPI("SUBGHZ", baudrate=8_000_000),
+            stm.subghz_cs,
+            stm.subghz_is_busy,
+            DIO1(),
+            False,  # dio2_rf_sw
+            tcxo_millivolts,  # dio3_tcxo_millivolts
+            10_000,  # dio3_tcxo_start_time_us, first time after POR is quite long
+            None,  # reset
+            lora_cfg,
+            ant_sw,
+        )
+
+    def _clear_errors(self):
+        # A weird difference between STM32WL55 and SX1262, WL55 only takes one
+        # parameter byte for the Clr_Error() command compared to two on SX1262.
+        # The bytes are always zero in both cases.
+        #
+        # (Not clear if sending two bytes will also work always/sometimes, but
+        # sending one byte to SX1262 definitely does not work!
+        self._cmd("BB", _CMD_CLR_ERRORS, 0x00)
+
+    def _clear_irq(self, clear_bits=0xFFFF):
+        super()._clear_irq(clear_bits)
+        # SUBGHZ Radio IRQ requires manual re-enabling after interrupt
+        stm.subghz_irq(self._radio_isr)
+
+    def _tx_hp(self):
+        # STM32WL5 supports both High and Low Power antenna pins depending on tx_ant setting
+        return self._hp
+
+    def _get_pa_tx_params(self, output_power, tx_ant):
+        # Given an output power level in dBm and the tx_ant setting (if any),
+        # return settings for SetPaConfig and SetTxParams.
+        #
+        # ST document RM0453 Set_PaConfig() reference and accompanying Table 35
+        # show values that are an exact superset of the SX1261 and SX1262
+        # available values, depending on which antenna pin is to be
+        # used. Therefore, call either modem's existing _get_pa_tx_params()
+        # function depending on the current tx_ant setting (default is low
+        # power).
+
+        if tx_ant is not None:
+            # Note: currently HP antenna power output is less than it should be,
+            # due to some (unknown) bug.
+            self._hp = tx_ant == "PA_BOOST"
+
+        # Update the OCP register to match the maximum power level
+        self._reg_write(_REG_OCP, 0x38 if self._hp else 0x18)
+
+        if self._hp:
+            return sx126x._SX1262._get_pa_tx_params(self, output_power, tx_ant)
+        else:
+            return sx126x._SX1261._get_pa_tx_params(self, output_power, tx_ant)
+
+
+# Define the actual modem classes that use the SyncModem & AsyncModem "mixin-like" classes
+# to create sync and async variants.
+
+try:
+    from .sync_modem import SyncModem
+
+    class WL55SubGhzModem(_WL55SubGhzModem, SyncModem):
+        pass
+
+except ImportError:
+    pass
+
+try:
+    from .async_modem import AsyncModem
+
+    class AsyncWL55SubGhzModem(_WL55SubGhzModem, AsyncModem):
+        pass
+
+except ImportError:
+    pass
+
+
+__version__ = '0.1'