reader-integration-kit 1.4.2__py3-none-win_amd64.whl

reader_integration_kit/structures/rik_result.py

@@ -0,0 +1,71 @@
+from ctypes import Structure, c_bool, c_char, c_int
+
+
+class RikResult(Structure):
+    """
+    Result structure for Reader layer operations.
+    Contains both reader-level and protocol-level exception information.
+    """
+    _fields_ = [
+        ("HasException", c_bool),
+        ("ExceptionType", c_char * 256),
+        ("Message", c_char * 2048),
+        ("FileName", c_char * 2048),
+        ("LineNumber", c_int),
+        ("FunctionName", c_char * 256),
+        ("HasProtocolException", c_bool),
+        ("ProtocolExceptionType", c_char * 256),
+        ("ProtocolMessage", c_char * 2048),
+        ("ProtocolFileName", c_char * 2048),
+        ("ProtocolLineNumber", c_int),
+        ("ProtocolFunctionName", c_char * 256),
+    ]
+
+    @property
+    def has_exception(self):
+        return self.HasException
+
+    @property
+    def exception_type(self):
+        return self.ExceptionType.decode('utf-8') if self.ExceptionType else None
+
+    @property
+    def message(self):
+        return self.Message.decode('utf-8') if self.Message else None
+
+    @property
+    def file_name(self):
+        return self.FileName.decode('utf-8') if self.FileName else None
+
+    @property
+    def line_number(self):
+        return self.LineNumber
+
+    @property
+    def function_name(self):
+        return self.FunctionName.decode('utf-8') if self.FunctionName else None
+
+    @property
+    def has_protocol_exception(self):
+        return self.HasProtocolException
+
+    @property
+    def protocol_exception_type(self):
+        return self.ProtocolExceptionType.decode('utf-8') if self.ProtocolExceptionType else None
+
+    @property
+    def protocol_message(self):
+        return self.ProtocolMessage.decode('utf-8') if self.ProtocolMessage else None
+
+    @property
+    def protocol_file_name(self):
+        return self.ProtocolFileName.decode('utf-8') if self.ProtocolFileName else None
+
+    @property
+    def protocol_line_number(self):
+        return self.ProtocolLineNumber
+
+    @property
+    def protocol_function_name(self):
+        return self.ProtocolFunctionName.decode('utf-8') if self.ProtocolFunctionName else None
+

reader_integration_kit/structures/separator_character.py

@@ -0,0 +1,44 @@
+from ctypes import Structure, c_uint8
+from typing import Any
+
+class SeparatorCharacter(Structure):    
+    _fields_ = [
+        ("USBKeyScanCode", c_uint8),
+        ("KeyModifier", c_uint8)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.USBKeyScanCode = kw.get("USBKeyScanCode", args[0] if len(args) > 0 else 0)
+        self.KeyModifier = kw.get("KeyModifier", args[1] if len(args) > 1 else 0)
+
+    def __str__(self):
+        return (
+            f"USBKeyScanCode: {self.USBKeyScanCode}\n"
+            f"KeyModifier: {self.KeyModifier}\n"
+        )
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, other):
+        return (
+            self.USBKeyScanCode == other.USBKeyScanCode
+            and self.KeyModifier == other.KeyModifier
+        )
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+    
+    def to_dict(self):
+        return {
+            "USBKeyScanCode": self.USBKeyScanCode,
+            "KeyModifier": self.KeyModifier
+        }
+
+    @classmethod
+    def from_bytes(cls, byte_array):
+        return cls(USBKeyScanCode=byte_array[0], KeyModifier=byte_array[1])
+
+    def to_bytes(self):
+        return bytes([self.USBKeyScanCode, self.KeyModifier])

reader_integration_kit/structures/separator_entry.py

@@ -0,0 +1,73 @@
+from ctypes import Structure, c_uint8
+from typing import Any
+
+from reader_integration_kit.structures.separator_character import SeparatorCharacter
+
+class SeparatorEntry(Structure):    
+    _fields_ = [
+        ("SeparatorValid", c_uint8),
+        ("CharacterSize", c_uint8),
+        ("VirtualCharacterCount", c_uint8),
+        ("ByteOffset", c_uint8),
+        ("SeparatorCharacters", SeparatorCharacter * 31)
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.SeparatorValid = kw.get("SeparatorValid", args[0] if len(args) > 0 else 0)
+        self.CharacterSize = kw.get("CharacterSize", args[1] if len(args) > 1 else 0)
+        self.VirtualCharacterCount = kw.get("VirtualCharacterCount", args[2] if len(args) > 2 else 0)
+        self.ByteOffset = kw.get("ByteOffset", args[3] if len(args) > 3 else 0)
+        self.SeparatorCharacters = (SeparatorCharacter * 31)(*kw.get("SeparatorCharacters", [SeparatorCharacter()]*31))
+
+    def __str__(self):
+        separator_chars_str = '\n'.join([f'Separator character {i}: \n{str(self.SeparatorCharacters[i])}' for i in range(self.VirtualCharacterCount)])
+        return (
+            f"SeparatorValid: {self.SeparatorValid}\n"
+            f"CharacterSize: {self.CharacterSize}\n"
+            f"VirtualCharacterCount: {self.VirtualCharacterCount}\n"
+            f"ByteOffset: {self.ByteOffset}\n"
+            f"SeparatorCharacters: \n{separator_chars_str}\n"
+        )
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, other):
+        return (
+            self.SeparatorValid == other.SeparatorValid
+            and self.CharacterSize == other.CharacterSize
+            and self.VirtualCharacterCount == other.VirtualCharacterCount
+            and self.ByteOffset == other.ByteOffset
+            and all(self.SeparatorCharacters[i] == other.SeparatorCharacters[i] for i in range(self.VirtualCharacterCount))
+        )
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def to_dict(self):
+        return {
+            "SeparatorValid": self.SeparatorValid,
+            "CharacterSize": self.CharacterSize,
+            "VirtualCharacterCount": self.VirtualCharacterCount,
+            "ByteOffset": self.ByteOffset,
+            "SeparatorCharacters": [self.SeparatorCharacters[i].to_dict() for i in range(self.VirtualCharacterCount)]
+        }
+    
+    @classmethod
+    def from_bytes(cls, byte_array):
+        return cls(
+            SeparatorValid=byte_array[0],
+            CharacterSize=byte_array[1],
+            VirtualCharacterCount=byte_array[2],
+            ByteOffset=byte_array[3],
+            SeparatorCharacters=[SeparatorCharacter.from_bytes(byte_array[4 + i*2: 6 + i*2]) for i in range(31)]
+        )
+
+    def to_bytes(self):
+        return bytes([
+            self.SeparatorValid,
+            self.CharacterSize,
+            self.VirtualCharacterCount,
+            self.ByteOffset
+        ]) + b''.join([self.SeparatorCharacters[i].to_bytes() for i in range(31)])

reader_integration_kit/structures/serial_port_settings.py

@@ -0,0 +1,45 @@
+from ctypes import Structure, c_int, c_char, c_uint32, c_uint8, memset, memmove, addressof
+
+from reader_integration_kit.enum.serial_port_baud_rate import SerialPortBaudRate
+from reader_integration_kit.enum.serial_port_data_bits import SerialPortDataBits
+from reader_integration_kit.enum.serial_port_flow_control import SerialPortFlowControl
+from reader_integration_kit.enum.serial_port_parity import SerialPortParity
+from reader_integration_kit.enum.serial_port_stop_bits import SerialPortStopBits
+
+
+class SerialPortSettings(Structure):
+    _pack_ = 1  # Ensure no padding between fields for native compatibility
+    _fields_ = [
+        ("BaudRate", c_uint32),
+        ("Parity", c_uint8),
+        ("FlowControl", c_uint8),
+        ("PortName", c_char * 256),
+        ("ByteSize", c_int),
+        ("DataBits", c_uint8),
+        ("StopBits", c_uint8),
+    ]
+
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        self.BaudRate = 0
+        self.Parity = 0
+        self.FlowControl = 0
+        self.ByteSize = 0
+        self.DataBits = 0
+        self.StopBits = 0
+        self.port_name = ""  # Use property setter to initialize PortName
+
+    @property
+    def port_name(self):
+        return bytes(self.PortName).decode('utf-8').rstrip('\x00')
+
+    @port_name.setter
+    def port_name(self, value):
+        encoded = value.encode('utf-8')
+        if len(encoded) > 255:
+            raise ValueError("PortName too long (max 255 bytes)")
+        base_addr = addressof(self)
+        field_offset = type(self).PortName.offset
+        field_addr = base_addr + field_offset
+        memset(field_addr, 0, 256)
+        memmove(field_addr, encoded, len(encoded))

reader_integration_kit/structures/smart_card_configuration.py

@@ -0,0 +1,34 @@
+from ctypes import Structure, c_uint8
+from typing import Any
+
+from reader_integration_kit.structures.blob_header import BlobHeader
+
+class SmartCardConfigurationStruct(Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("Header", BlobHeader),
+        ("Data", c_uint8 * (4 * 0xFE)),
+    ]
+
+    def __init__(self, *args: Any, **kw: Any):
+        super().__init__()
+        self.Header = kw.get("Header", args[0] if len(args) > 0 else BlobHeader())
+        self.Data = kw.get("Data", args[1] if len(args) > 1 else (c_uint8 * (4 * 0xFE))())
+
+    def __str__(self):
+        return (f"SmartCardConfigurationStruct:\n" +
+                f"Header:\n{self.Header}" +
+                f"Data: {list(self.Data)}\n"
+                )
+
+    def __eq__(self, other):
+        return self.Header == other.Header and self.Data[:] == other.Data[:]
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def to_dict(self):
+        return {
+            "Header": self.Header.to_dict(),
+            "Data": list(self.Data),
+        }

reader_integration_kit-1.4.2.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: reader-integration-kit
+Version: 1.4.2
+Summary: A Python wrapper for the rfIDEAS Reader Integration Kit library
+Home-page: https://docs.rfideas.com/rik/
+Author: rf IDEAS, Inc.
+Author-email: appdev@rfideas.com
+Project-URL: Documentation, https://docs.rfideas.com/rik/
+Project-URL: Homepage, https://www.rfideas.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: rfIDEAS_EULA.txt
+Requires-Dist: setuptools>=42
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Reader Integration Kit - Python Binding
+
+A Python wrapper for the rf IDEAS Reader Integration Kit native library. This package enables Python
+applications to communicate with rf IDEAS readers using a high-level reader interface.
+
+## Supported Platforms
+
+This package ships platform-tagged wheels for all supported architectures.
+`pip` automatically selects the correct wheel for your operating system and CPU:
+
+| Platform / Architecture | Wheel tag |
+|---|---|
+| Linux x86_64 | `manylinux_*_x86_64` |
+| Linux ARM64 (generic aarch64 and Raspberry Pi 5) | `manylinux_*_aarch64` |
+| Linux 32-bit ARM hard-float (ARMhf / armv7) | `manylinux_*_armv7l` |
+| Windows x86_64 | `win_amd64` |
+
+## Installation
+
+Install from PyPI with a single command — no need to pick a platform-specific package name:
+
+```sh
+pip install reader-integration-kit
+```
+
+### Raspberry Pi 5 runtime detection
+
+The `linux_aarch64` wheel bundles both the Pi 5-optimized and the generic ARM64 native library.
+The correct variant is selected automatically at import time by reading `/proc/device-tree/model`.
+You can override this for testing with the `RIK_ARM_VARIANT` environment variable:
+
+```sh
+RIK_ARM_VARIANT=pi5     python my_script.py   # force Pi 5 variant
+RIK_ARM_VARIANT=generic python my_script.py   # force generic variant
+```
+
+### Backward-compatible package names
+
+Users upgrading from the old per-platform package names (e.g.
+`reader-integration-kit-linux-x86-64`) will be automatically redirected to this unified
+package via pip's dependency resolution — no manual action is required.
+
+### Prerequisites
+
+- Windows 10/11 (x64), Linux x64, or Linux ARM64 / ARMhf (Ubuntu 24.04+ or equivalent)
+- A connected rf IDEAS reader (USB or serial), e.g. WaveID
+- Python 3.8 or later
+- On Linux, appropriate udev rules may be required for USB reader access
+
+## Usage
+
+Import the `reader_integration_kit` module and create an instance of `Reader`. The facade uses
+handles to manage reader instances, allowing you to interact with multiple readers concurrently.
+
+### WaveID Reader Example
+
+```python
+import reader_integration_kit.facade as reader
+from reader_integration_kit.structures import ReaderDefinition, DeviceId, SerialPortSettings
+from reader_integration_kit.enum import ProtocolType, BeepDuration, BeepVolume
+
+# Create a reader definition for WaveID
+reader_def = ReaderDefinition(
+    DeviceId=DeviceId(VendorId=0x0c27, ProductId=0x3bfa),
+    ProtocolType=ProtocolType.FEATURE_REPORT,
+    SerialPortSettings=SerialPortSettings()
+)
+
+# Create a WaveID reader instance
+with reader.Reader(reader_def, retry_count=3) as waveid:
+    # Initialize the reader
+    waveid.init()
+
+    # Get reader metadata (populated lazily on first access)
+    metadata_dict = waveid.get_metadata()
+    print(f"Part Number: {metadata_dict.get('PartNumber', 'N/A')}")
+
+    # Force refresh metadata from device
+    metadata_dict = waveid.get_metadata(force_refresh=True)
+
+    # Beep the reader
+    waveid.beep(2, BeepDuration.BEEP_DURATION_SHORT)
+
+    # Get beeper volume
+    volume = waveid.get_beeper_volume()
+    print(f"Beeper Volume: {volume}")
+
+    # Set beeper volume
+    waveid.set_beeper_volume(BeepVolume.BEEP_VOLUME_HIGH)
+```
+
+**Note:** The `Reader` class manages reader handles internally. Each instance corresponds to
+a single reader handle. You can create multiple `Reader` instances to interact with multiple readers
+simultaneously. Resources are automatically released when exiting the context manager (`with`
+statement) or when the object is garbage collected.
+
+## Documentation
+
+For integration guides and complete API reference, see the
+[rf IDEAS Documentation](https://docs.rfideas.com/rik/).
+
+## License
+
+This package is proprietary software distributed by rf IDEAS, Inc. Use of this package is subject to
+the End-User License Agreement (EULA) included with the package. See the included `rfIDEAS_EULA.txt` for
+full terms and conditions.
+
+---
+Copyright rf IDEAS, Inc. All rights reserved.

reader_integration_kit-1.4.2.dist-info/RECORD

@@ -0,0 +1,56 @@
+reader_integration_kit/__init__.py,sha256=LnQ5YxChqpVVhO7P18fv9LFxISIipLVx7BdA__dFaRE,168
+reader_integration_kit/enum/__init__.py,sha256=JBQr1NBTBJm3sJhmA58lwwokfo9pCRjoASTz56TuhiQ,1825
+reader_integration_kit/enum/beep_duration.py,sha256=L69Gqlpps5_ltTI0scpebxJgCy5uzkTdEsRShVdzwwo,246
+reader_integration_kit/enum/beep_volume.py,sha256=s9gYbjY4u2-JQD3s0EE6evI1yhba0QqAPehk9K59qEo,319
+reader_integration_kit/enum/ble_data_type.py,sha256=XwUNYp83vKAHfhzswmxUzJCjWlMKi-2uvsVP43GJdfA,238
+reader_integration_kit/enum/blob_type.py,sha256=hmfsNstOewBYQN0we1DrP5Y2QJHOLWJ2Sh7MqXTNdTo,614
+reader_integration_kit/enum/checkpoint_type.py,sha256=j5rCpdwobI7T0PjdOhWWPOGjJK-dAGoELYECsMcfm0A,277
+reader_integration_kit/enum/data_conversion_type.py,sha256=ldxdTFW6CEcmY38jaJyVSGRvkkECjOqW_ZKwHDY0Dkk,259
+reader_integration_kit/enum/field_definition_type.py,sha256=4hz5mvr3eP9hjJcimxNIDMJROlnaHdeAc7yCf2COxcM,337
+reader_integration_kit/enum/led_color.py,sha256=FXCSZQdVz4z3yYpnx0JCEXVlJknAXZyPc20NjC-e0U0,281
+reader_integration_kit/enum/protocol_type.py,sha256=-1mhzcY3Vnn7u_oJ1iQKTCt1Xd-h-DoxLiiOCom4rVs,280
+reader_integration_kit/enum/proximity_card_type.py,sha256=7cN3PZ-8UkMfwEujawTZ5Ypa6wtbHyBuLf-RmmK-liI,4182
+reader_integration_kit/enum/reader_module_id.py,sha256=zRSEeE4H1pAH_UcOxzOgGmefMpeYwYDCt0tAoEgdDYE,295
+reader_integration_kit/enum/reader_module_state.py,sha256=KygIv7AMqNvFOnh0TbyT45mLrNX6YCgqNOYEQkXBaLM,237
+reader_integration_kit/enum/serial_port_baud_rate.py,sha256=qJDcPusKVYQaEnP0yF3LTuuriiGXr8o741Tt3axm8xg,292
+reader_integration_kit/enum/serial_port_data_bits.py,sha256=51QM1S4EKCAgEikuP7a_cykN2wiRXzJqITgcnPdLNEQ,159
+reader_integration_kit/enum/serial_port_flow_control.py,sha256=7bgcdDzcn4CUCFgqAFstP3CAPZGP8ydZNj57mEZPlJ4,189
+reader_integration_kit/enum/serial_port_parity.py,sha256=1k2SF0qny_D9nO9yYzATl0EUz-FPqbrG_7qwf-gW8L8,126
+reader_integration_kit/enum/serial_port_stop_bits.py,sha256=c0FLQn9C6TIpDQbWcfu3WLHOkXR5eaCehXAkpsPN3OM,123
+reader_integration_kit/enum/transparent_mode_state.py,sha256=IVwY3bkInxQmxX3Bzip24XO4usdFDNePZ1VlTSbQ7XE,231
+reader_integration_kit/enum/transparent_mode_status.py,sha256=4E2yjZpPHrsSiyDQYfLmPimMXZpQQRpzwliZEbEI5oo,231
+reader_integration_kit/errors/__init__.py,sha256=19IOnV3-emL0hZIMoYnUniHudgV2roWjJ1zQTAOYSpU,107
+reader_integration_kit/errors/reader_exception.py,sha256=tGPmTpw4zi7QeRfI3c7ko0Tppnunmc9Rq7AewEPWHf4,2205
+reader_integration_kit/facade/__init__.py,sha256=930gSsra1XyIwRcOT1yDpklMlUh_w57_q9lnzF_ktSo,37330
+reader_integration_kit/lib/ReaderIntegrationKit.dll,sha256=08T3BL0oLXUHs7S8fJm61ir_FmX244AZV7Bzq4lh60M,1681760
+reader_integration_kit/structures/__init__.py,sha256=Q3U3VQ7CqipXU2ahQaM9_Y6esWY_-Uz8jhvR_bCRX4Y,2736
+reader_integration_kit/structures/blob_header.py,sha256=l40zHqws2APeYv0C8OaoP3d_c7-hirEri60H13qpsHQ,1796
+reader_integration_kit/structures/bluetooth_firmware_version.py,sha256=JtN1crXXCZ_FtH9DFcqeB2wu-SBRZNpPziok5qrnPA0,1152
+reader_integration_kit/structures/card_data.py,sha256=nwNZpRGLgesPiEFyTcHX0l2Z3hjLzPLZrOI0D6D4gxQ,2241
+reader_integration_kit/structures/card_type_info.py,sha256=gQKKNvn2jlJRe-k_OB4jASgSNy90k07Y_HHe-p_I9_o,1773
+reader_integration_kit/structures/device_id.py,sha256=k2tORHCv3SpgY7MeYYTxBTnc1ppELcyIQNREHnk-ow8,255
+reader_integration_kit/structures/extended_configuration.py,sha256=2GJjs_Y6fAYhLULvkNT8Z0DvzXuOVNp7VLgiz51q2o8,1461
+reader_integration_kit/structures/felica_sam_firmware_version.py,sha256=Z1yg0CXkh4dUgw7_4wCnGnn1fjWmO3S4wvbUDQ_0NKY,1304
+reader_integration_kit/structures/field_entry.py,sha256=RoXYfETArcx24CFHG_g6J08gheD2R4PxGHNXzSGP634,5032
+reader_integration_kit/structures/field_separator_data_header.py,sha256=3IWqSi3deQRehu9y-s0WUx6wznJmYJChITcjxnRbjiQ,3477
+reader_integration_kit/structures/hash_data.py,sha256=gwKd8Hnq1iCyFgnTd-8-0sxLyJ6ewgOVbwjbYZxD2GY,2016
+reader_integration_kit/structures/hid_se_sam_firmware_version.py,sha256=oV6_fjw8MIJsidIm4qXfy5buhC5K_B5KMI7st8JX1vs,1237
+reader_integration_kit/structures/led_configuration.py,sha256=mPn-Dk8F9dcbIFo4slCaSNs5JCchVLnbQIFZmdDKH7A,420
+reader_integration_kit/structures/library_info.py,sha256=eQRyA3MCR3uJ5nlkdG7em9EC_YAH73MbxRmHu7KvxYo,3670
+reader_integration_kit/structures/luid_response_information.py,sha256=r96UcTAG8UI57iFLMPx27-T2oM7RhzhBEkVwNOBuLJ8,1820
+reader_integration_kit/structures/microcontroller_firmware_version.py,sha256=N1O3oMOsjdztxXhCY43kP9EMxd1nwUfeHV2ISsRCBzI,1343
+reader_integration_kit/structures/nxp_sam_firmware_version.py,sha256=MxJPizFDmoIYW1dctWAx3yuIKMsp1FaUJg1JWBrJyNY,1212
+reader_integration_kit/structures/reader_configuration.py,sha256=gOB43HKviqo34WDENPSukjonDBN2mk2oyEpSiTdbRrw,8672
+reader_integration_kit/structures/reader_data.py,sha256=LMW46Qi0LaSahxQxc3ik0K2rO6Jk3Y3c_AkDB2L7SGY,1787
+reader_integration_kit/structures/reader_definition.py,sha256=a4QGtc0V71b3zJ6mFnkYkTA3RKq1M3fB7PWvDNx_Djw,420
+reader_integration_kit/structures/reader_metadata_struct.py,sha256=3Rvp4raj9bGHSur_1Vr1hykYEs35dsZ-YeHxCrXEfpM,9591
+reader_integration_kit/structures/rik_result.py,sha256=CP2krRfK-reGmoMwFLSRGkQRvZtpcH22DTA_XOXWRkM,2107
+reader_integration_kit/structures/separator_character.py,sha256=_xEGXi_tNBT3v4yuCn8HbyZQfH9Nn18ZBNxZWhX6wzk,1253
+reader_integration_kit/structures/separator_entry.py,sha256=mL4PcVE5XhE4xUCaThkb_KaYBRADb6-D7U2657Df9Rc,3010
+reader_integration_kit/structures/serial_port_settings.py,sha256=ef7n4QTXWopBItTi6FYRgeZgCkbdhLmRmmAiS8fYMrY,1682
+reader_integration_kit/structures/smart_card_configuration.py,sha256=jhB0LLl4oOt_FSCdy_L6iMRGNS_QugtowuTvWgVYfBs,1030
+reader_integration_kit-1.4.2.dist-info/licenses/rfIDEAS_EULA.txt,sha256=3ys0lZp_osLz7TmKsLWsY6UX3rHvfmpDeyCMSztNp14,19390
+reader_integration_kit-1.4.2.dist-info/METADATA,sha256=z7BmAIx6XAZ6pu0bPMPJjIE9UHYRHV6tlvdsJZqc8kA,4924
+reader_integration_kit-1.4.2.dist-info/WHEEL,sha256=GjDPPQwEcripVP6P2r3RxLa-h5Lb9ifGB7FYYtbLDT0,98
+reader_integration_kit-1.4.2.dist-info/top_level.txt,sha256=K6Z4idV-ujuFpJSFQgiY_LM5IzNEa6juAmENqnKFcB0,23
+reader_integration_kit-1.4.2.dist-info/RECORD,,

reader_integration_kit-1.4.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+