Fix n_args_min on many MP_DEFINE_CONST_FUN_OBJ_KW()

locale/circuitpython.pot

@@ -3943,6 +3943,7 @@ msgstr ""
 #: ports/espressif/boards/adafruit_funhouse/mpconfigboard.h
 #: ports/espressif/boards/adafruit_magtag_2.9_grayscale/mpconfigboard.h
 #: ports/espressif/boards/adafruit_metro_esp32s2/mpconfigboard.h
+#: ports/espressif/boards/ai_thinker_esp32-c3s/mpconfigboard.h
 #: ports/espressif/boards/ai_thinker_esp_12k_nodemcu/mpconfigboard.h
 #: ports/espressif/boards/artisense_rd00/mpconfigboard.h
 #: ports/espressif/boards/atmegazero_esp32s2/mpconfigboard.h
@@ -3961,6 +3962,7 @@ msgstr ""
 #: ports/espressif/boards/gravitech_cucumber_rs/mpconfigboard.h
 #: ports/espressif/boards/lilygo_ttgo_t8_s2_st7789/mpconfigboard.h
 #: ports/espressif/boards/lolin_s2_mini/mpconfigboard.h
+#: ports/espressif/boards/microdev_micro_c3/mpconfigboard.h
 #: ports/espressif/boards/microdev_micro_s2/mpconfigboard.h
 #: ports/espressif/boards/morpheans_morphesp-240/mpconfigboard.h
 #: ports/espressif/boards/muselab_nanoesp32_s2_wroom/mpconfigboard.h

shared-bindings/_bleio/Adapter.c

@@ -271,7 +271,7 @@ STATIC mp_obj_t bleio_adapter_start_advertising(mp_uint_t n_args, const mp_obj_t
 
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_adapter_start_advertising_obj, 2, bleio_adapter_start_advertising);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_adapter_start_advertising_obj, 1, bleio_adapter_start_advertising);
 
 //|     def stop_advertising(self) -> None:
 //|         """Stop sending advertising packets."""
@@ -456,7 +456,7 @@ STATIC mp_obj_t bleio_adapter_connect(mp_uint_t n_args, const mp_obj_t *pos_args
 
     return common_hal_bleio_adapter_connect(self, address, timeout);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_adapter_connect_obj, 2, bleio_adapter_connect);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_adapter_connect_obj, 1, bleio_adapter_connect);
 
 //|     def erase_bonding(self) -> None:
 //|         """Erase all bonding information stored in flash memory."""

shared-bindings/_bleio/Characteristic.c

@@ -156,7 +156,7 @@ STATIC mp_obj_t bleio_characteristic_add_to_service(size_t n_args, const mp_obj_
 
     return MP_OBJ_FROM_PTR(characteristic);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_characteristic_add_to_service_fun_obj, 3, bleio_characteristic_add_to_service);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_characteristic_add_to_service_fun_obj, 1, bleio_characteristic_add_to_service);
 STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(bleio_characteristic_add_to_service_obj, MP_ROM_PTR(&bleio_characteristic_add_to_service_fun_obj));
 
 

shared-bindings/_bleio/Descriptor.c

@@ -136,7 +136,7 @@ STATIC mp_obj_t bleio_descriptor_add_to_characteristic(size_t n_args, const mp_o
 
     return MP_OBJ_FROM_PTR(descriptor);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_descriptor_add_to_characteristic_fun_obj, 3, bleio_descriptor_add_to_characteristic);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_descriptor_add_to_characteristic_fun_obj, 1, bleio_descriptor_add_to_characteristic);
 STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(bleio_descriptor_add_to_characteristic_obj, MP_ROM_PTR(&bleio_descriptor_add_to_characteristic_fun_obj));
 
 //|     uuid: UUID

shared-bindings/_bleio/ScanEntry.c

@@ -72,7 +72,7 @@ STATIC mp_obj_t bleio_scanentry_matches(mp_uint_t n_args, const mp_obj_t *pos_ar
     mp_get_buffer_raise(args[ARG_prefixes].u_obj, &bufinfo, MP_BUFFER_READ);
     return mp_obj_new_bool(common_hal_bleio_scanentry_matches(self, bufinfo.buf, bufinfo.len, match_all));
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_scanentry_matches_obj, 2, bleio_scanentry_matches);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_scanentry_matches_obj, 1, bleio_scanentry_matches);
 
 //|     address: Address
 //|     """The address of the device (read-only), of type `_bleio.Address`."""

shared-bindings/_bleio/UUID.c

@@ -214,7 +214,7 @@ STATIC mp_obj_t bleio_uuid_pack_into(mp_uint_t n_args, const mp_obj_t *pos_args,
     common_hal_bleio_uuid_pack_into(self, bufinfo.buf + offset);
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_uuid_pack_into_obj, 2, bleio_uuid_pack_into);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bleio_uuid_pack_into_obj, 1, bleio_uuid_pack_into);
 
 STATIC const mp_rom_map_elem_t bleio_uuid_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_uuid16), MP_ROM_PTR(&bleio_uuid_uuid16_obj) },

shared-bindings/adafruit_bus_device/I2CDevice.c

@@ -63,7 +63,8 @@
 //|                     device.readinto(bytes_read)
 //|                 # A second transaction
 //|                 with device:
-//|                     device.write(bytes_read)"""
+//|                     device.write(bytes_read)
+//|     """
 //|     ...
 //|
 STATIC mp_obj_t adafruit_bus_device_i2cdevice_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
@@ -109,16 +110,18 @@ STATIC mp_obj_t adafruit_bus_device_i2cdevice_obj___exit__(size_t n_args, const
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(adafruit_bus_device_i2cdevice___exit___obj, 4, 4, adafruit_bus_device_i2cdevice_obj___exit__);
 
-//|     def readinto(self, buf: WriteableBuffer, *, start: int = 0, end: Optional[int] = None) -> None:
-//|         """Read into ``buf`` from the device. The number of bytes read will be the
-//|         length of ``buf``.
+//|     import sys
+//|     def readinto(self, buffer: WriteableBuffer, *, start: int = 0, end: int = sys.maxsize) -> None:
+//|         """Read into ``buffer`` from the device.
+//|
 //|         If ``start`` or ``end`` is provided, then the buffer will be sliced
-//|         as if ``buf[start:end]``. This will not cause an allocation like
-//|         ``buf[start:end]`` will so it saves memory.
+//|         as if ``buffer[start:end]`` were passed.
+//|         The number of bytes read will be the length of ``buffer[start:end]``.
 //|
-//|         :param bytearray buf: buffer to write into
-//|         :param int start: Index to start writing at
-//|         :param int end: Index to write up to but not include; if None, use ``len(buf)``"""
+//|         :param WriteableBuffer buffer: read bytes into this buffer
+//|         :param int start: beginning of buffer slice
+//|         :param int end: end of buffer slice; if not specified, use ``len(buffer)``
+//|         """
 //|         ...
 //|
 STATIC mp_obj_t adafruit_bus_device_i2cdevice_readinto(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
@@ -152,17 +155,19 @@ STATIC mp_obj_t adafruit_bus_device_i2cdevice_readinto(size_t n_args, const mp_o
 
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(adafruit_bus_device_i2cdevice_readinto_obj, 2, adafruit_bus_device_i2cdevice_readinto);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(adafruit_bus_device_i2cdevice_readinto_obj, 1, adafruit_bus_device_i2cdevice_readinto);
 
-//|     def write(self, buf: ReadableBuffer, *, start: int = 0, end: Optional[int] = None) -> None:
+//|     import sys
+//|     def write(self, buffer: ReadableBuffer, *, start: int = 0, end: int = sys.maxsize) -> None:
 //|         """Write the bytes from ``buffer`` to the device, then transmit a stop bit.
+//|
 //|         If ``start`` or ``end`` is provided, then the buffer will be sliced
-//|         as if ``buffer[start:end]``. This will not cause an allocation like
-//|         ``buffer[start:end]`` will so it saves memory.
+//|         as if ``buffer[start:end]`` were passed, but without copying the data.
+//|         The number of bytes written will be the length of ``buffer[start:end]``.
 //|
-//|         :param bytearray buf: buffer containing the bytes to write
-//|         :param int start: Index to start writing from
-//|         :param int end: Index to read up to but not include; if None, use ``len(buf)``
+//|         :param ReadableBuffer buffer: write out bytes from this buffer
+//|         :param int start: beginning of buffer slice
+//|         :param int end: end of buffer slice; if not specified, use ``len(buffer)``
 //|         """
 //|         ...
 //|
@@ -196,28 +201,28 @@ STATIC mp_obj_t adafruit_bus_device_i2cdevice_write(size_t n_args, const mp_obj_
 
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_KW(adafruit_bus_device_i2cdevice_write_obj, 2, adafruit_bus_device_i2cdevice_write);
+MP_DEFINE_CONST_FUN_OBJ_KW(adafruit_bus_device_i2cdevice_write_obj, 1, adafruit_bus_device_i2cdevice_write);
 
 
-//|     def write_then_readinto(self, out_buffer: WriteableBuffer, in_buffer: ReadableBuffer, *, out_start: int = 0, out_end: Optional[int] = None, in_start: int = 0, in_end: Optional[int] = None) -> None:
+//|     import sys
+//|     def write_then_readinto(self, out_buffer: ReadableBuffer, in_buffer: WriteableBuffer, *, out_start: int = 0, out_end: int = sys.maxsize, in_start: int = 0, in_end: int = sys.maxsize) -> None:
 //|         """Write the bytes from ``out_buffer`` to the device, then immediately
-//|         reads into ``in_buffer`` from the device. The number of bytes read
-//|         will be the length of ``in_buffer``.
-//|         If ``out_start`` or ``out_end`` is provided, then the output buffer
-//|         will be sliced as if ``out_buffer[out_start:out_end]``. This will
-//|         not cause an allocation like ``buffer[out_start:out_end]`` will so
-//|         it saves memory.
-//|         If ``in_start`` or ``in_end`` is provided, then the input buffer
-//|         will be sliced as if ``in_buffer[in_start:in_end]``. This will not
-//|         cause an allocation like ``in_buffer[in_start:in_end]`` will so
-//|         it saves memory.
+//|         reads into ``in_buffer`` from the device.
+//|
+//|         If ``out_start`` or ``out_end`` is provided, then the buffer will be sliced
+//|         as if ``out_buffer[out_start:out_end]`` were passed, but without copying the data.
+//|         The number of bytes written will be the length of ``out_buffer[out_start:out_end]``.
+//|
+//|         If ``in_start`` or ``in_end`` is provided, then the input buffer will be sliced
+//|         as if ``in_buffer[in_start:in_end]`` were passed,
+//|         The number of bytes read will be the length of ``out_buffer[in_start:in_end]``.
 //|
-//|         :param bytearray out_buffer: buffer containing the bytes to write
-//|         :param bytearray in_buffer: buffer containing the bytes to read into
-//|         :param int out_start: Index to start writing from
-//|         :param int out_end: Index to read up to but not include; if None, use ``len(out_buffer)``
-//|         :param int in_start: Index to start writing at
-//|         :param int in_end: Index to write up to but not include; if None, use ``len(in_buffer)``
+//|         :param ReadableBuffer out_buffer: write out bytes from this buffer
+//|         :param WriteableBuffer in_buffer: read bytes into this buffer
+//|         :param int out_start: beginning of ``out_buffer`` slice
+//|         :param int out_end: end of ``out_buffer`` slice; if not specified, use ``len(out_buffer)``
+//|         :param int in_start: beginning of ``in_buffer`` slice
+//|         :param int in_end: end of ``in_buffer slice``; if not specified, use ``len(in_buffer)``
 //|         """
 //|         ...
 //|
@@ -263,7 +268,7 @@ STATIC mp_obj_t adafruit_bus_device_i2cdevice_write_then_readinto(size_t n_args,
 
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_KW(adafruit_bus_device_i2cdevice_write_then_readinto_obj, 3, adafruit_bus_device_i2cdevice_write_then_readinto);
+MP_DEFINE_CONST_FUN_OBJ_KW(adafruit_bus_device_i2cdevice_write_then_readinto_obj, 1, adafruit_bus_device_i2cdevice_write_then_readinto);
 
 STATIC const mp_rom_map_elem_t adafruit_bus_device_i2cdevice_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&adafruit_bus_device_i2cdevice___enter___obj) },

shared-bindings/bitbangio/I2C.c

@@ -165,7 +165,8 @@ STATIC mp_obj_t bitbangio_i2c_obj_unlock(mp_obj_t self_in) {
 }
 MP_DEFINE_CONST_FUN_OBJ_1(bitbangio_i2c_unlock_obj, bitbangio_i2c_obj_unlock);
 
-//|     def readfrom_into(self, address: int, buffer: WriteableBuffer, *, start: int = 0, end: Optional[int] = None) -> None:
+//|     import sys
+//|     def readfrom_into(self, address: int, buffer: WriteableBuffer, *, start: int = 0, end: int = sys.maxsize) -> None:
 //|         """Read into ``buffer`` from the device selected by ``address``.
 //|         The number of bytes read will be the length of ``buffer``.
 //|         At least one byte must be read.
@@ -175,7 +176,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(bitbangio_i2c_unlock_obj, bitbangio_i2c_obj_unlock);
 //|         ``buf[start:end]`` will so it saves memory.
 //|
 //|         :param int address: 7-bit device address
-//|         :param ~_typing.WriteableBuffer buffer: buffer to write into
+//|         :param WriteableBuffer buffer: buffer to write into
 //|         :param int start: Index to start writing at
 //|         :param int end: Index to write up to but not include"""
 //|         ...
@@ -215,24 +216,26 @@ STATIC mp_obj_t bitbangio_i2c_readfrom_into(size_t n_args, const mp_obj_t *pos_a
         args[ARG_end].u_int);
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_KW(bitbangio_i2c_readfrom_into_obj, 3, bitbangio_i2c_readfrom_into);
+MP_DEFINE_CONST_FUN_OBJ_KW(bitbangio_i2c_readfrom_into_obj, 1, bitbangio_i2c_readfrom_into);
 
-//|     def writeto(self, address: int, buffer: ReadableBuffer, *, start: int = 0, end: Optional[int] = None) -> None:
+//|     import sys
+//|     def writeto(self, address: int, buffer: ReadableBuffer, *, start: int = 0, end: int = sys.maxsize) -> None:
 //|         """Write the bytes from ``buffer`` to the device selected by ``address`` and then transmits a
 //|         stop bit. Use `writeto_then_readfrom` when needing a write, no stop and repeated start
 //|         before a read.
 //|
 //|         If ``start`` or ``end`` is provided, then the buffer will be sliced
-//|         as if ``buffer[start:end]``. This will not cause an allocation like
-//|         ``buffer[start:end]`` will so it saves memory.
+//|         as if ``buffer[start:end]`` were passed, but without copying the data.
+//|         The number of bytes written will be the length of ``buffer[start:end]``.
 //|
 //|         Writing a buffer or slice of length zero is permitted, as it can be used
 //|         to poll for the existence of a device.
 //|
 //|         :param int address: 7-bit device address
-//|         :param ~_typing.ReadableBuffer buffer: buffer containing the bytes to write
-//|         :param int start: Index to start writing from
-//|         :param int end: Index to read up to but not include"""
+//|         :param ReadableBuffer buffer: buffer containing the bytes to write
+//|         :param int start: beginning of buffer slice
+//|         :param int end: end of buffer slice; if not specified, use ``len(buffer)``
+//|         """
 //|         ...
 //|
 // Shared arg parsing for writeto and writeto_then_readfrom.
@@ -274,22 +277,29 @@ STATIC mp_obj_t bitbangio_i2c_writeto(size_t n_args, const mp_obj_t *pos_args, m
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(bitbangio_i2c_writeto_obj, 1, bitbangio_i2c_writeto);
 
 
-//|     def writeto_then_readfrom(self, address: int, out_buffer: ReadableBuffer, in_buffer: ReadableBuffer, *, out_start: int = 0, out_end: Optional[int] = None, in_start: int = 0, in_end: Optional[int] = None) -> None:
+//|     import sys
+//|     def writeto_then_readfrom(self, address: int, out_buffer: ReadableBuffer, in_buffer: ReadableBuffer, *, out_start: int = 0, out_end: int = sys.maxsize, in_start: int = 0, in_end: int = sys.maxsize) -> None:
 //|         """Write the bytes from ``out_buffer`` to the device selected by ``address``, generate no stop
 //|         bit, generate a repeated start and read into ``in_buffer``. ``out_buffer`` and
 //|         ``in_buffer`` can be the same buffer because they are used sequentially.
 //|
-//|         If ``start`` or ``end`` is provided, then the corresponding buffer will be sliced
-//|         as if ``buffer[start:end]``. This will not cause an allocation like ``buf[start:end]``
-//|         will so it saves memory.
+//|         If ``out_start`` or ``out_end`` is provided, then the buffer will be sliced
+//|         as if ``out_buffer[out_start:out_end]`` were passed, but without copying the data.
+//|         The number of bytes written will be the length of ``out_buffer[start:end]``.
 //|
+//|         If ``in_start`` or ``in_end`` is provided, then the input buffer will be sliced
+//|         as if ``in_buffer[in_start:in_end]`` were passed,
+//|         The number of bytes read will be the length of ``out_buffer[in_start:in_end]``.
+
 //|         :param int address: 7-bit device address
 //|         :param ~_typing.ReadableBuffer out_buffer: buffer containing the bytes to write
 //|         :param ~_typing.WriteableBuffer in_buffer: buffer to write into
-//|         :param int out_start: Index to start writing from
-//|         :param int out_end: Index to read up to but not include. Defaults to ``len(buffer)``
-//|         :param int in_start: Index to start writing at
-//|         :param int in_end: Index to write up to but not include. Defaults to ``len(buffer)``"""
+//|         :param int out_start: beginning of ``out_buffer`` slice
+//|         :param int out_end: end of ``out_buffer`` slice; if not specified, use ``len(out_buffer)``
+//|         :param int in_start: beginning of ``in_buffer`` slice
+//|         :param int in_end: end of ``in_buffer slice``; if not specified, use ``len(in_buffer)``
+//|         """
+//|         ...
 //|
 STATIC mp_obj_t bitbangio_i2c_writeto_then_readfrom(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum { ARG_address, ARG_out_buffer, ARG_in_buffer, ARG_out_start, ARG_out_end, ARG_in_start, ARG_in_end };
@@ -315,7 +325,7 @@ STATIC mp_obj_t bitbangio_i2c_writeto_then_readfrom(size_t n_args, const mp_obj_
 
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_KW(bitbangio_i2c_writeto_then_readfrom_obj, 3, bitbangio_i2c_writeto_then_readfrom);
+MP_DEFINE_CONST_FUN_OBJ_KW(bitbangio_i2c_writeto_then_readfrom_obj, 1, bitbangio_i2c_writeto_then_readfrom);
 
 STATIC const mp_rom_map_elem_t bitbangio_i2c_locals_dict_table[] = {
     { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&bitbangio_i2c_deinit_obj) },