mcumgr-toolkit 0.8.0__cp310-abi3-musllinux_1_2_aarch64.whl

mcumgr_toolkit/__init__.py

@@ -0,0 +1,5 @@
+from .mcumgr_toolkit import *
+
+__doc__ = mcumgr_toolkit.__doc__
+if hasattr(mcumgr_toolkit, "__all__"):
+    __all__ = mcumgr_toolkit.__all__

mcumgr_toolkit/__init__.pyi

@@ -0,0 +1,564 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import builtins
+import collections.abc
+import datetime
+import enum
+import typing
+
+@typing.final
+class FileChecksum:
+    r"""
+    Return value of `MCUmgrClient.fs_file_checksum`.
+    """
+    @property
+    def type(self) -> builtins.str:
+        r"""
+        type of hash/checksum that was performed
+        """
+    @property
+    def offset(self) -> builtins.int:
+        r"""
+        offset that hash/checksum calculation started at
+        """
+    @property
+    def length(self) -> builtins.int:
+        r"""
+        length of input data used for hash/checksum generation (in bytes)
+        """
+    @property
+    def output(self) -> bytes:
+        r"""
+        output hash/checksum
+        """
+
+@typing.final
+class FileChecksumProperties:
+    r"""
+    Properties of a hash/checksum algorithm
+    """
+    @property
+    def format(self) -> 'FileChecksumDataFormat':
+        r"""
+        format that the hash/checksum returns
+        """
+    @property
+    def size(self) -> builtins.int:
+        r"""
+        size (in bytes) of output hash/checksum response
+        """
+
+@typing.final
+class FileStatus:
+    r"""
+    Return value of `MCUmgrClient.fs_file_status`.
+    """
+    @property
+    def length(self) -> builtins.int:
+        r"""
+        length of file (in bytes)
+        """
+
+@typing.final
+class ImageState:
+    r"""
+    The state of an image slot
+    """
+    @property
+    def image(self) -> builtins.int:
+        r"""
+        image number
+        """
+    @property
+    def slot(self) -> builtins.int:
+        r"""
+        slot number within “image”
+        """
+    @property
+    def version(self) -> builtins.str:
+        r"""
+        string representing image version, as set with `imgtool`
+        """
+    @property
+    def hash(self) -> typing.Optional[bytes]:
+        r"""
+        SHA256 hash of the image header and body
+        
+        Note that this will not be the same as the SHA256 of the whole file, it is the field in the
+        MCUboot TLV section that contains a hash of the data which is used for signature
+        verification purposes.
+        """
+    @property
+    def bootable(self) -> builtins.bool:
+        r"""
+        true if image has bootable flag set
+        """
+    @property
+    def pending(self) -> builtins.bool:
+        r"""
+        true if image is set for next swap
+        """
+    @property
+    def confirmed(self) -> builtins.bool:
+        r"""
+        true if image has been confirmed
+        """
+    @property
+    def active(self) -> builtins.bool:
+        r"""
+        true if image is currently active application
+        """
+    @property
+    def permanent(self) -> builtins.bool:
+        r"""
+        true if image is to stay in primary slot after the next boot
+        """
+
+@typing.final
+class MCUmgrClient:
+    r"""
+    A high-level client for Zephyr's MCUmgr SMP functionality
+    """
+    @staticmethod
+    def serial(serial: builtins.str, baud_rate: builtins.int = 115200, timeout_ms: builtins.int = 10000) -> 'MCUmgrClient':
+        r"""
+        Creates a new serial port based Zephyr MCUmgr SMP client.
+        
+        ### Arguments
+        
+        * `serial` - The identifier of the serial device. (Windows: `COMxx`, Linux: `/dev/ttyXX`)
+        * `baud_rate` - The baud rate of the serial port.
+        * `timeout_ms` - The communication timeout, in ms.
+        """
+    @staticmethod
+    def usb_serial(identifier: builtins.str, baud_rate: builtins.int = 115200, timeout_ms: builtins.int = 10000) -> 'MCUmgrClient':
+        r"""
+        Creates a Zephyr MCUmgr SMP client based on a USB serial port identified by VID:PID.
+        
+        Useful for programming many devices in rapid succession, as Windows usually
+        gives each one a different COMxx identifier.
+        
+        ### Arguments
+        
+        * `identifier` - A regex that identifies the device.
+        * `baud_rate` - The baud rate the port should operate at.
+        * `timeout_ms` - The communication timeout, in ms.
+        
+        ### Identifier examples
+        
+        - `1234:89AB` - Vendor ID 1234, Product ID 89AB. Will fail if product has multiple serial ports.
+        - `1234:89AB:12` - Vendor ID 1234, Product ID 89AB, Interface 12.
+        - `1234:.*:[2-3]` - Vendor ID 1234, any Product Id, Interface 2 or 3.
+        """
+    def set_frame_size(self, smp_frame_size: builtins.int) -> None:
+        r"""
+        Configures the maximum SMP frame size that we can send to the device.
+        
+        Must not exceed [`MCUMGR_TRANSPORT_NETBUF_SIZE`](https://github.com/zephyrproject-rtos/zephyr/blob/v4.2.1/subsys/mgmt/mcumgr/transport/Kconfig#L40),
+        otherwise we might crash the device.
+        """
+    def use_auto_frame_size(self) -> None:
+        r"""
+        Configures the maximum SMP frame size that we can send to the device automatically
+        by reading the value of [`MCUMGR_TRANSPORT_NETBUF_SIZE`](https://github.com/zephyrproject-rtos/zephyr/blob/v4.2.1/subsys/mgmt/mcumgr/transport/Kconfig#L40)
+        from the device.
+        """
+    def set_timeout_ms(self, timeout_ms: builtins.int) -> None:
+        r"""
+        Changes the communication timeout.
+        
+        When the device does not respond to packets within the set
+        duration, an error will be raised.
+        """
+    def check_connection(self) -> None:
+        r"""
+        Checks if the device is alive and responding.
+        
+        Runs a simple echo with random data and checks if the response matches.
+        
+        Raises an error if the device is not alive and responding.
+        """
+    def firmware_update(self, firmware: bytes, checksum: typing.Optional[builtins.str | builtins.bytes] = None, bootloader_type: typing.Optional[typing.Literal['MCUboot']] = None, skip_reboot: builtins.bool = False, force_confirm: builtins.bool = False, upgrade_only: builtins.bool = False, progress: typing.Optional[collections.abc.Callable[[builtins.str, typing.Optional[builtins.tuple[builtins.int, builtins.int]]], None]] = None) -> None:
+        r"""
+        High-level firmware update routine.
+        
+        ### Arguments
+        
+        * `firmware` - The firmware image data.
+        * `checksum` - SHA256 of the firmware image. Optional.
+        * `bootloader_type` - The type of bootloader. Auto-detect bootloader if missing.
+        * `skip_reboot` - Do not reboot device after the update.
+        * `force_confirm` - Skip test boot and confirm directly.
+        * `upgrade_only` - Prevent firmware downgrades.
+        * `progress` - A callback that receives progress updates.
+        """
+    def os_echo(self, msg: builtins.str) -> builtins.str:
+        r"""
+        Sends a message to the device and expects the same message back as response.
+        
+        This can be used as a sanity check for whether the device is connected and responsive.
+        """
+    def os_task_statistics(self) -> 'builtins.dict[builtins.str, TaskStatistics]':
+        r"""
+        Queries live task statistics
+        
+        ### Note
+        
+        Converts `stkuse` and `stksiz` to bytes.
+        Zephyr originally reports them as number of 4 byte words.
+        
+        ### Return
+        
+        A map of task names with their respective statistics
+        """
+    def os_set_datetime(self, datetime: datetime.datetime) -> None:
+        r"""
+        Sets the RTC of the device to the given datetime.
+        
+        Uses the contained local time and discards timezone information.
+        """
+    def os_get_datetime(self) -> datetime.datetime:
+        r"""
+        Retrieves the device RTC's datetime.
+        
+        Will not contain timezone information.
+        """
+    def os_system_reset(self, force: builtins.bool = False, boot_mode: typing.Optional[builtins.int] = None) -> None:
+        r"""
+        Issues a system reset.
+        
+        ### Arguments
+        
+        * `force` - Issues a force reset.
+        * `boot_mode` - Overwrites the default boot mode.
+        
+        Known `boot_mode` values:
+        * `0` - Normal system boot
+        * `1` - Bootloader recovery mode
+        
+        Note that `boot_mode` only works if [`MCUMGR_GRP_OS_RESET_BOOT_MODE`](https://docs.zephyrproject.org/latest/kconfig.html#CONFIG_MCUMGR_GRP_OS_RESET_BOOT_MODE) is enabled.
+        """
+    def os_mcumgr_parameters(self) -> 'MCUmgrParameters':
+        r"""
+        Fetch parameters from the MCUmgr library
+        """
+    def os_application_info(self, format: typing.Optional[builtins.str] = None) -> builtins.str:
+        r"""
+        Fetch information on the running image
+        
+        Similar to Linux's `uname` command.
+        
+        ### Arguments
+        
+        * `format` - Format specifier for the returned response
+        
+        For more information about the format specifier fields, see
+        the [SMP documentation](https://docs.zephyrproject.org/latest/services/device_mgmt/smp_groups/smp_group_0.html#os-application-info-request).
+        """
+    def os_bootloader_info(self) -> typing.Any:
+        r"""
+        Fetch information on the device's bootloader
+        """
+    def image_get_state(self) -> 'builtins.list[ImageState]':
+        r"""
+        Obtain a list of images with their current state.
+        """
+    def image_set_state(self, hash: typing.Optional[builtins.str | builtins.bytes] = None, confirm: builtins.bool = False) -> 'builtins.list[ImageState]':
+        r"""
+        Modify the current image state and return the new state
+        
+        ### Arguments
+        
+        * `hash` - the SHA256 id of the image.
+        * `confirm` - mark the given image as 'confirmed'
+        
+        If `confirm` is `false`, perform a test boot with the given image and revert upon hard reset.
+        
+        If `confirm` is `true`, boot to the given image and mark it as `confirmed`. If `hash` is omitted,
+        confirm the currently running image.
+        
+        Note that `hash` will not be the same as the SHA256 of the whole firmware image,
+        it is the field in the MCUboot TLV section that contains a hash of the data
+        which is used for signature verification purposes.
+        """
+    def image_upload(self, data: bytes, image: typing.Optional[builtins.int] = None, checksum: typing.Optional[builtins.str | builtins.bytes] = None, upgrade_only: builtins.bool = False, progress: typing.Optional[collections.abc.Callable[[builtins.int, builtins.int], None]] = None) -> None:
+        r"""
+        Upload a firmware image to an image slot.
+        
+        ### Arguments
+        
+        * `data` - The firmware image data
+        * `image` - Selects target image on the device. Defaults to `0`.
+        * `checksum` - The SHA256 checksum of the image. If missing, will be computed from the image data.
+        * `upgrade_only` - If true, allow firmware upgrades only and reject downgrades.
+        * `progress` - A callable object that takes (transmitted, total) values as parameters.
+                       Any return value is ignored. Raising an exception aborts the operation.
+        
+        ### Performance
+        
+        Uploading files with Zephyr's default parameters is slow.
+        You want to increase [`MCUMGR_TRANSPORT_NETBUF_SIZE`](https://github.com/zephyrproject-rtos/zephyr/blob/v4.2.1/subsys/mgmt/mcumgr/transport/Kconfig#L40)
+        to maybe `4096` and then enable larger chunking through either `set_frame_size`
+        or `use_auto_frame_size`.
+        """
+    def image_erase(self, slot: typing.Optional[builtins.int] = None) -> None:
+        r"""
+        Erase image slot on target device.
+        
+        ### Arguments
+        
+        * `slot` - The slot ID of the image to erase. Slot `1` if omitted.
+        """
+    def image_slot_info(self) -> 'builtins.list[SlotInfoImage]':
+        r"""
+        Obtain a list of available image slots.
+        """
+    def fs_file_download(self, name: builtins.str, progress: typing.Optional[collections.abc.Callable[[builtins.int, builtins.int], None]] = None) -> bytes:
+        r"""
+        Load a file from the device.
+        
+        ### Arguments
+        
+        * `name` - The full path of the file on the device.
+        * `progress` - A callable object that takes (transmitted, total) values as parameters.
+                       Any return value is ignored. Raising an exception aborts the operation.
+        
+        ### Return
+        
+        The file content
+        
+        ### Performance
+        
+        Downloading files with Zephyr's default parameters is slow.
+        You want to increase [`MCUMGR_TRANSPORT_NETBUF_SIZE`](https://github.com/zephyrproject-rtos/zephyr/blob/v4.2.1/subsys/mgmt/mcumgr/transport/Kconfig#L40)
+        to maybe `4096` or larger.
+        """
+    def fs_file_upload(self, name: builtins.str, data: bytes, progress: typing.Optional[collections.abc.Callable[[builtins.int, builtins.int], None]] = None) -> None:
+        r"""
+        Write a file to the device.
+        
+        ### Arguments
+        
+        * `name` - The full path of the file on the device.
+        * `data` - The file content.
+        * `progress` - A callable object that takes (transmitted, total) values as parameters.
+                       Any return value is ignored. Raising an exception aborts the operation.
+        
+        ### Performance
+        
+        Uploading files with Zephyr's default parameters is slow.
+        You want to increase [`MCUMGR_TRANSPORT_NETBUF_SIZE`](https://github.com/zephyrproject-rtos/zephyr/blob/v4.2.1/subsys/mgmt/mcumgr/transport/Kconfig#L40)
+        to maybe `4096` and then enable larger chunking through either `set_frame_size`
+        or `use_auto_frame_size`.
+        """
+    def fs_file_status(self, name: builtins.str) -> 'FileStatus':
+        r"""
+        Queries the file status
+        """
+    def fs_file_checksum(self, name: builtins.str, algorithm: typing.Optional[builtins.str] = None, offset: builtins.int = 0, length: typing.Optional[builtins.int] = None) -> 'FileChecksum':
+        r"""
+        Computes the hash/checksum of a file
+        
+        For available algorithms, see `fs_supported_checksum_types`.
+        
+        ### Arguments
+        
+        * `name` - The absolute path of the file on the device
+        * `algorithm` - The hash/checksum algorithm to use, or default if None
+        * `offset` - How many bytes of the file to skip
+        * `length` - How many bytes to read after `offset`. None for the entire file.
+        """
+    def fs_supported_checksum_types(self) -> 'builtins.dict[builtins.str, FileChecksumProperties]':
+        r"""
+        Queries which hash/checksum algorithms are available on the target
+        """
+    def fs_file_close(self) -> None:
+        r"""
+        Close all device files MCUmgr has currently open
+        """
+    def shell_execute(self, argv: typing.Sequence[builtins.str]) -> builtins.str:
+        r"""
+        Run a shell command.
+        
+        ### Arguments
+        
+        * `argv` - The shell command to be executed.
+        
+        ### Return
+        
+        The command output
+        """
+    def zephyr_erase_storage(self) -> None:
+        r"""
+        Erase the `storage_partition` flash partition.
+        """
+    def raw_command(self, write_operation: builtins.bool, group_id: builtins.int, command_id: builtins.int, data: typing.Any) -> typing.Any:
+        r"""
+        Execute a raw MCUmgrCommand.
+        
+        Only returns if no error happened, so the
+        user does not need to check for an `rc` or `err`
+        field in the response.
+        
+        Read Zephyr's [SMP Protocol Specification](https://docs.zephyrproject.org/latest/services/device_mgmt/smp_protocol.html)
+        for more information.
+        
+        ### Arguments
+        
+        * `write_operation` - Whether the command is a read or write operation.
+        * `group_id` - The group ID of the command
+        * `command_id` - The command ID
+        * `data` - Anything that can be serialized as a proper packet payload.
+        
+        ### Example
+        
+        ```python
+        client.raw_command(True, 0, 0, {"d": "Hello!"})
+        # Returns: {'r': 'Hello!'}
+        ```
+        """
+    def __enter__(self) -> 'MCUmgrClient': ...
+    def __exit__(self, _exc_type: typing.Any, _exc_value: typing.Any, _traceback: typing.Any) -> builtins.bool:
+        r"""
+        Closes the connection
+        """
+
+@typing.final
+class MCUmgrParameters:
+    r"""
+    Return value of `MCUmgrClient.os_mcumgr_parameters`.
+    """
+    @property
+    def buf_size(self) -> builtins.int:
+        r"""
+        Single SMP buffer size, this includes SMP header and CBOR payload
+        """
+    @property
+    def buf_count(self) -> builtins.int:
+        r"""
+        Number of SMP buffers supported
+        """
+
+@typing.final
+class McubootImageInfo:
+    r"""
+    Information about an MCUboot firmware image
+    """
+    @property
+    def version(self) -> builtins.str:
+        r"""
+        Firmware version
+        """
+    @property
+    def hash(self) -> bytes:
+        r"""
+        The identifying hash for the firmware
+        
+        Note that this will not be the same as the SHA256 of the whole file, it is the field in the
+        MCUboot TLV section that contains a hash of the data which is used for signature
+        verification purposes.
+        """
+
+@typing.final
+class SlotInfoImage:
+    r"""
+    Information about a firmware image type returned by `MCUmgrClient.image_slot_info`
+    """
+    @property
+    def image(self) -> builtins.int:
+        r"""
+        number of the image
+        """
+    @property
+    def slots(self) -> 'builtins.list[SlotInfoImageSlot]':
+        r"""
+        slots available for the image
+        """
+    @property
+    def max_image_size(self) -> typing.Optional[builtins.int]:
+        r"""
+        maximum size of an application that can be uploaded to that image number
+        """
+
+@typing.final
+class SlotInfoImageSlot:
+    r"""
+    Information about a slot that can hold a firmware image
+    """
+    @property
+    def slot(self) -> builtins.int:
+        r"""
+        slot inside the image being enumerated
+        """
+    @property
+    def size(self) -> builtins.int:
+        r"""
+        size of the slot
+        """
+    @property
+    def upload_image_id(self) -> typing.Optional[builtins.int]:
+        r"""
+        specifies the image ID that can be used by external tools to upload an image to that slot
+        """
+
+@typing.final
+class TaskStatistics:
+    r"""
+    Statistics of an MCU task/thread
+    """
+    @property
+    def prio(self) -> builtins.int:
+        r"""
+        task priority
+        """
+    @property
+    def tid(self) -> builtins.int:
+        r"""
+        numeric task ID
+        """
+    @property
+    def state(self) -> builtins.int:
+        r"""
+        numeric task state
+        """
+    @property
+    def stkuse(self) -> typing.Optional[builtins.int]:
+        r"""
+        task’s/thread’s stack usage
+        """
+    @property
+    def stksiz(self) -> typing.Optional[builtins.int]:
+        r"""
+        task’s/thread’s stack size
+        """
+    @property
+    def cswcnt(self) -> typing.Optional[builtins.int]:
+        r"""
+        task’s/thread’s context switches
+        """
+    @property
+    def runtime(self) -> typing.Optional[builtins.int]:
+        r"""
+        task’s/thread’s runtime in “ticks”
+        """
+
+@typing.final
+class FileChecksumDataFormat(enum.Enum):
+    r"""
+    Data format of the hash/checksum type
+    """
+    Numerical = ...
+    r"""
+    Data is a number
+    """
+    ByteArray = ...
+    r"""
+    Data is a bytes array
+    """
+
+def mcuboot_get_image_info(image_data: bytes) -> 'McubootImageInfo':
+    r"""
+    Extract information from an MCUboot image file
+    """
+

mcumgr_toolkit-0.8.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: mcumgr-toolkit
+Version: 0.8.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Summary: Python API for Zephyr's MCUmgr protocol
+Keywords: zephyr,mcumgr,smp
+Author: Finomnis <finomnis@gmail.com>
+Author-email: Finomnis <finomnis@gmail.com>
+License: MIT OR Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://finomnis.github.io/mcumgr-toolkit
+Project-URL: Issues, https://github.com/Finomnis/mcumgr-toolkit/issues
+Project-URL: Repository, https://github.com/Finomnis/mcumgr-toolkit
+
+# MCUmgr Client for Zephyr
+
+[![Crates.io](https://img.shields.io/crates/v/mcumgr-toolkit)](https://crates.io/crates/mcumgr-toolkit)
+[![PyPI - Version](https://img.shields.io/pypi/v/mcumgr_toolkit)](https://pypi.org/project/mcumgr-toolkit)
+[![PyPI - Downloads](https://img.shields.io/pypi/dw/mcumgr-toolkit)](https://pypi.org/project/mcumgr-toolkit)
+[![License](https://img.shields.io/crates/l/mcumgr-toolkit)](https://github.com/Finomnis/mcumgr-toolkit/blob/main/LICENSE-MIT)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/Finomnis/mcumgr-toolkit/ci.yml?branch=main)](https://github.com/Finomnis/mcumgr-toolkit/actions/workflows/ci.yml?query=branch%3Amain)
+[![Docs Status](https://img.shields.io/github/actions/workflow/status/Finomnis/mcumgr-toolkit/python-docs.yml?branch=main&label=docs)](https://finomnis.github.io/mcumgr-toolkit)
+
+This library provides a Rust-based Python API for Zephyr's [MCUmgr protocol](https://docs.zephyrproject.org/latest/services/device_mgmt/mcumgr.html).
+
+It might be compatible with other MCUmgr/SMP-based systems, but it is developed with Zephyr in mind.
+
+Its primary design goals are:
+- Completeness
+  - cover all use cases of Zephyr's MCUmgr
+  - for implementation progress, see this [tracking issue](https://github.com/Finomnis/mcumgr-toolkit/issues/32)
+- Performance
+  - use static memory and large buffers to prioritize performance
+    over memory footprint
+  - see further down for more information regarding performance
+    optimizations required on Zephyr side
+
+
+## Usage Example
+
+Connect to a serial port:
+
+```python no_run
+from mcumgr_toolkit import MCUmgrClient
+
+with MCUmgrClient.serial("/dev/ttyACM0") as client:
+    client.use_auto_frame_size()
+
+    print(client.os_echo("Hello world!"))
+```
+
+```none
+Hello world!
+```
+
+Or a USB-based serial port:
+
+```python no_run
+from mcumgr_toolkit import MCUmgrClient
+
+with MCUmgrClient.usb_serial("2fe3:0004") as client:
+    client.use_auto_frame_size()
+
+    print(client.os_echo("Hello world!"))
+```
+
+```none
+Hello world!
+```
+
+For more information, take a look at the [API reference](https://finomnis.github.io/mcumgr-toolkit).
+
+## Performance
+
+Zephyr's default buffer sizes are quite small and reduce the read/write performance drastically.
+
+The central most important setting is [`MCUMGR_TRANSPORT_NETBUF_SIZE`](https://github.com/zephyrproject-rtos/zephyr/blob/v4.2.1/subsys/mgmt/mcumgr/transport/Kconfig#L40). Its default of 384 bytes is very limiting, both for performance and as cutoff for large responses, like `os_task_statistics()` or some shell commands.
+
+Be aware that changing this value also requires an increase of `MCUMGR_TRANSPORT_WORKQUEUE_STACK_SIZE` to prevent overflow crashes.
+
+In practice, I found that the following values work quite well (on i.MX RT1060)
+and give me 410 KB/s read and 120 KB/s write throughput, which is an order of magnitude faster than the default settings.
+
+```kconfig
+CONFIG_MCUMGR_TRANSPORT_NETBUF_SIZE=4096
+CONFIG_MCUMGR_TRANSPORT_WORKQUEUE_STACK_SIZE=8192
+```
+
+If the experience differs on other chips, please open an issue and let me know.
+
+## Contributions
+
+Contributions are welcome!
+
+I primarily wrote this crate for myself, so any ideas for improvements are greatly appreciated.
+

mcumgr_toolkit-0.8.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mcumgr_toolkit/__init__.py,sha256=aNpktJ85aHlzINiO7hf6o5VM4_BTKwfM5ALW9kWbqyk,139
+mcumgr_toolkit/__init__.pyi,sha256=4M7x1y7dj_ugdnE28pi9cPMce_5mUbibKnGd2ytBJW4,19760
+mcumgr_toolkit/mcumgr_toolkit.abi3.so,sha256=iTUBa44pAbiicZpdLaFkyeLJw0YOGXCcU-X76mzUj5E,4656561
+mcumgr_toolkit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcumgr_toolkit-0.8.0.dist-info/METADATA,sha256=KqzJ9lkiBfcsZT0HdjKDBQQ2hv4JSAd_LsPDNEnc1ws,4350
+mcumgr_toolkit-0.8.0.dist-info/WHEEL,sha256=Ks4MlrbXuBUzn0Sg1pSlfobz-J5L_KK83ofsy7dBTdk,108
+mcumgr_toolkit.libs/libgcc_s-0bf60adc.so.1,sha256=9fhX5YpiwtHdsiLMLz77Pw9jjIEGriteV7UOUrrwvpk,527681
+mcumgr_toolkit-0.8.0.dist-info/RECORD,,

mcumgr_toolkit-0.8.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp310-abi3-musllinux_1_2_aarch64