polar-python 0.0.1__py3-none-any.whl

polar_python/__init__.py

@@ -0,0 +1,11 @@
+from .device import PolarDevice
+from .constants import MeasurementSettings, SettingType, ECGData, ACCData, HRData
+
+__all__ = [
+    "PolarDevice",
+    "MeasurementSettings",
+    "SettingType",
+    "ECGData",
+    "ACCData",
+    "HRData",
+]

polar_python/constants.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+# UUIDs for Polar device characteristics
+HEART_RATE_CHAR_UUID: str = "00002a37-0000-1000-8000-00805f9b34fb"
+PMD_CONTROL_POINT_UUID: str = "FB005C81-02E7-F387-1CAD-8ACD2D8DF0C8"
+PMD_DATA_UUID: str = "FB005C82-02E7-F387-1CAD-8ACD2D8DF0C8"
+
+# PMD Measurement Types
+PMD_MEASUREMENT_TYPES: List[str] = ["ECG", "PPG", "ACC", "PPI", "RFU", "GYRO", "MAG"]
+
+# PMD Control Point Error Codes
+PMD_CONTROL_POINT_ERROR_CODES: List[str] = [
+    "SUCCESS",
+    "ERROR INVALID OP CODE",
+    "ERROR INVALID MEASUREMENT TYPE",
+    "ERROR NOT SUPPORTED",
+    "ERROR INVALID LENGTH",
+    "ERROR INVALID PARAMETER",
+    "ERROR ALREADY IN STATE",
+    "ERROR INVALID RESOLUTION",
+    "ERROR INVALID SAMPLE RATE",
+    "ERROR INVALID RANGE",
+    "ERROR INVALID MTU",
+    "ERROR INVALID NUMBER OF CHANNELS",
+    "ERROR INVALID STATE",
+    "ERROR DEVICE IN CHARGER",
+]
+
+# PMD Control Operation Codes
+PMD_CONTROL_OPERATION_CODE: dict = {"GET": 0x01, "START": 0x02, "STOP": 0x03}
+
+# PMD Setting Types
+PMD_SETTING_TYPES: List[str] = ["SAMPLE_RATE", "RESOLUTION", "RANGE", "RFU", "CHANNELS"]
+
+# Timestamp Offset
+TIMESTAMP_OFFSET: int = 946684800000000000
+
+
+@dataclass
+class SettingType:
+    """Represents a setting type with its array length and possible values."""
+
+    type: str
+    array_length: int
+    values: List[int]
+
+
+@dataclass
+class MeasurementSettings:
+    """Represents measurement settings for a specific type."""
+
+    measurement_type: str
+    settings: List[SettingType]
+    error_code: Optional[str] = None
+    more_frames: Optional[bool] = None
+
+
+@dataclass
+class ACCData:
+    """Represents accelerometer data."""
+
+    timestamp: int
+    data: List[Tuple[int, int, int]]
+
+
+@dataclass
+class ECGData:
+    """Represents ECG data."""
+
+    timestamp: int
+    data: List[int]
+
+
+@dataclass
+class HRData:
+    """Represents heart rate data."""
+
+    heartrate: int
+    rr_intervals: List[float]

polar_python/device.py

@@ -0,0 +1,171 @@
+import asyncio
+from bleak import BleakClient
+from bleak.backends.device import BLEDevice
+from bleak.backends.characteristic import BleakGATTCharacteristic
+from typing import Union, Callable, List
+
+from . import constants, exceptions, utils
+
+
+class PolarDevice:
+    def __init__(
+        self,
+        address_or_ble_device: Union[str, BLEDevice],
+        data_callback: Callable[
+            [Union[constants.ECGData, constants.ACCData]], None
+        ] = None,
+        heartrate_callback: Callable[[constants.HRData], None] = None,
+    ) -> None:
+        """
+        Initialize the PolarDevice with a BLE address or device.
+
+        :param address_or_ble_device: The address or BLEDevice instance of the Polar device.
+        :param data_callback: Callback function to handle data streams.
+        :param heartrate_callback: Callback function to handle heart rate data.
+        """
+        self.client = BleakClient(address_or_ble_device)
+        self._queue_pmd_control = asyncio.Queue()
+        self._data_callback = data_callback
+        self._heartrate_callback = heartrate_callback
+
+    async def connect(self) -> None:
+        """Connect to the Polar device."""
+        try:
+            await self.client.connect()
+            await self.client.start_notify(
+                constants.PMD_CONTROL_POINT_UUID, self._handle_pmd_control
+            )
+            await self.client.start_notify(
+                constants.PMD_DATA_UUID, self._handle_pmd_data
+            )
+        except Exception as e:
+            raise exceptions.ConnectionError(
+                f"Failed to connect to the Polar device: {str(e)}"
+            ) from e
+
+    async def disconnect(self) -> None:
+        """Disconnect from the Polar device."""
+        try:
+            await self.client.disconnect()
+        except Exception as e:
+            raise exceptions.DisconnectionError(
+                f"Failed to disconnect from the Polar device: {str(e)}"
+            ) from e
+
+    async def __aenter__(self):
+        """Support for async context management."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Support for async context management."""
+        await self.disconnect()
+
+    async def available_features(self) -> List[str]:
+        """Retrieve available features from the Polar device."""
+        try:
+            data = await self.client.read_gatt_char(constants.PMD_CONTROL_POINT_UUID)
+            if data[0] != 0x0F:
+                raise exceptions.ControlPointResponseError(
+                    "Unexpected response from the control point"
+                )
+            features = data[1]
+            bitmap = utils.byte_to_bitmap(features)
+            return [
+                constants.PMD_MEASUREMENT_TYPES[int(index)]
+                for index, bit in enumerate(bitmap)
+                if bit
+            ]
+        except Exception as e:
+            raise exceptions.ReadCharacteristicError(
+                f"Failed to read available features: {str(e)}"
+            ) from e
+
+    async def request_stream_settings(
+        self, measurement_type: str
+    ) -> constants.MeasurementSettings:
+        """Request stream settings for a specific measurement type."""
+        try:
+            await self.client.write_gatt_char(
+                constants.PMD_CONTROL_POINT_UUID,
+                bytearray(
+                    [
+                        constants.PMD_CONTROL_OPERATION_CODE["GET"],
+                        constants.PMD_MEASUREMENT_TYPES.index(measurement_type),
+                    ]
+                ),
+            )
+            return utils.parse_pmd_data(await self._queue_pmd_control.get())
+        except Exception as e:
+            raise exceptions.StreamSettingsError(
+                f"Failed to request stream settings for {measurement_type}: {str(e)}"
+            ) from e
+
+    async def start_stream(self, settings: constants.MeasurementSettings) -> None:
+        """Start data stream with specified settings."""
+        try:
+            data = utils.build_measurement_settings(settings)
+            await self.client.write_gatt_char(constants.PMD_CONTROL_POINT_UUID, data)
+        except Exception as e:
+            raise exceptions.WriteCharacteristicError(
+                f"Failed to start stream with settings {settings}: {str(e)}"
+            ) from e
+
+    async def stop_stream(self, measurement_type: str) -> None:
+        """Stop data stream for a specific measurement type."""
+        try:
+            await self.client.write_gatt_char(
+                constants.PMD_CONTROL_POINT_UUID,
+                bytearray(
+                    [
+                        constants.PMD_CONTROL_OPERATION_CODE["STOP"],
+                        constants.PMD_MEASUREMENT_TYPES.index(measurement_type),
+                    ]
+                ),
+            )
+        except Exception as e:
+            raise exceptions.WriteCharacteristicError(
+                f"Failed to stop stream for {measurement_type}: {str(e)}"
+            ) from e
+
+    async def start_heartrate_stream(self) -> None:
+        """Start heart rate data stream."""
+        try:
+            await self.client.start_notify(
+                constants.HEART_RATE_CHAR_UUID, self._handle_heartrate_measurement
+            )
+        except Exception as e:
+            raise exceptions.NotificationError(
+                f"Failed to start heart rate stream: {str(e)}"
+            ) from e
+
+    async def stop_heartrate_stream(self) -> None:
+        """Stop heart rate data stream."""
+        try:
+            await self.client.stop_notify(constants.HEART_RATE_CHAR_UUID)
+        except Exception as e:
+            raise exceptions.NotificationError(
+                f"Failed to stop heart rate stream: {str(e)}"
+            ) from e
+
+    def _handle_pmd_control(
+        self, sender: BleakGATTCharacteristic, data: bytearray
+    ) -> None:
+        """Handle PMD control notifications."""
+        self._queue_pmd_control.put_nowait(data)
+
+    def _handle_pmd_data(
+        self, sender: BleakGATTCharacteristic, data: bytearray
+    ) -> None:
+        """Handle PMD data notifications."""
+        parsed_data = utils.parse_bluetooth_data(data)
+        if self._data_callback:
+            self._data_callback(parsed_data)
+
+    def _handle_heartrate_measurement(
+        self, sender: BleakGATTCharacteristic, data: bytearray
+    ) -> None:
+        """Handle heart rate measurement notifications."""
+        parsed_data = utils.parse_heartrate_data(data)
+        if self._heartrate_callback:
+            self._heartrate_callback(parsed_data)

polar_python/exceptions.py

@@ -0,0 +1,58 @@
+class PolarPythonError(Exception):
+    pass
+
+
+class ControlPointResponseError(PolarPythonError):
+    """Exception raised when there is an unexpected response from the control point."""
+
+    def __init__(self, message="Unexpected response from the control point"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class ConnectionError(PolarPythonError):
+    """Exception raised when the device fails to connect."""
+
+    def __init__(self, message="Failed to connect to the Polar device"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class DisconnectionError(PolarPythonError):
+    """Exception raised when the device fails to disconnect."""
+
+    def __init__(self, message="Failed to disconnect from the Polar device"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class NotificationError(PolarPythonError):
+    """Exception raised when notifications cannot be started or stopped."""
+
+    def __init__(self, message="Failed to start or stop notifications"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class ReadCharacteristicError(PolarPythonError):
+    """Exception raised when a GATT characteristic cannot be read."""
+
+    def __init__(self, message="Failed to read GATT characteristic"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class WriteCharacteristicError(PolarPythonError):
+    """Exception raised when a GATT characteristic cannot be written."""
+
+    def __init__(self, message="Failed to write GATT characteristic"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class StreamSettingsError(PolarPythonError):
+    """Exception raised when stream settings are invalid or cannot be set."""
+
+    def __init__(self, message="Invalid or failed to set stream settings"):
+        self.message = message
+        super().__init__(self.message)

polar_python/utils.py

@@ -0,0 +1,165 @@
+from typing import List, Tuple, Union
+from . import constants
+
+
+def byte_to_bitmap(byte: int) -> List[bool]:
+    """Convert a byte to a bitmap (list of booleans)."""
+    binary_string = f"{byte:08b}"
+    reversed_binary_string = binary_string[::-1]
+    return [bit == "1" for bit in reversed_binary_string]
+
+
+def parse_pmd_data(data: bytearray) -> constants.MeasurementSettings:
+    """Parse PMD data from a bytearray."""
+    try:
+        measurement_type_index = data[2]
+        error_code_index = data[3]
+        more_frames = data[4] != 0
+
+        measurement_type = (
+            constants.PMD_MEASUREMENT_TYPES[measurement_type_index]
+            if measurement_type_index < len(constants.PMD_MEASUREMENT_TYPES)
+            else "UNKNOWN"
+        )
+        error_code = (
+            constants.PMD_CONTROL_POINT_ERROR_CODES[error_code_index]
+            if error_code_index < len(constants.PMD_CONTROL_POINT_ERROR_CODES)
+            else "UNKNOWN"
+        )
+
+        settings = []
+        index = 5
+        while index < len(data):
+            setting_type_index = data[index]
+            setting_type = (
+                constants.PMD_SETTING_TYPES[setting_type_index]
+                if setting_type_index < len(constants.PMD_SETTING_TYPES)
+                else "UNKNOWN"
+            )
+            array_length = data[index + 1]
+            setting_values = [
+                int.from_bytes(data[index + 2 + 2 * i : index + 4 + 2 * i], "little")
+                for i in range(array_length)
+            ]
+            settings.append(
+                constants.SettingType(
+                    type=setting_type, array_length=array_length, values=setting_values
+                )
+            )
+            index += 2 + 2 * array_length
+
+        return constants.MeasurementSettings(
+            measurement_type=measurement_type,
+            error_code=error_code,
+            more_frames=more_frames,
+            settings=settings,
+        )
+    except IndexError as e:
+        raise ValueError("Failed to parse PMD data: insufficient data length") from e
+
+
+def build_measurement_settings(
+    measurement_settings: constants.MeasurementSettings,
+) -> bytearray:
+    """Build a bytearray from measurement settings."""
+    data = bytearray()
+    data.append(constants.PMD_CONTROL_OPERATION_CODE["START"])
+
+    measurement_type_index = constants.PMD_MEASUREMENT_TYPES.index(
+        measurement_settings.measurement_type
+    )
+    data.append(measurement_type_index)
+
+    for setting in measurement_settings.settings:
+        setting_type_index = constants.PMD_SETTING_TYPES.index(setting.type)
+        data.append(setting_type_index)
+        data.append(setting.array_length)
+        for value in setting.values:
+            data.extend(value.to_bytes(2, "little"))
+
+    return data
+
+
+def parse_ecg_data(data: List[int], timestamp: int) -> constants.ECGData:
+    """Parse ECG data from a list of integers."""
+    ecg_data = [
+        int.from_bytes(data[i : i + 3], byteorder="little", signed=True)
+        for i in range(10, len(data), 3)
+    ]
+    return constants.ECGData(timestamp=timestamp, data=ecg_data)
+
+
+def parse_acc_data(
+    data: List[int], timestamp: int, frame_type: int
+) -> constants.ACCData:
+    """Parse accelerometer data from a list of integers based on frame type."""
+    acc_data = []
+    if frame_type == 0x00:
+        acc_data = [
+            (
+                int.from_bytes(data[i : i + 1], byteorder="little", signed=True),
+                int.from_bytes(data[i + 1 : i + 2], byteorder="little", signed=True),
+                int.from_bytes(data[i + 2 : i + 3], byteorder="little", signed=True),
+            )
+            for i in range(10, len(data), 3)
+        ]
+    elif frame_type == 0x01:
+        acc_data = [
+            (
+                int.from_bytes(data[i : i + 2], byteorder="little", signed=True),
+                int.from_bytes(data[i + 2 : i + 4], byteorder="little", signed=True),
+                int.from_bytes(data[i + 4 : i + 6], byteorder="little", signed=True),
+            )
+            for i in range(10, len(data), 6)
+        ]
+    elif frame_type == 0x02:
+        acc_data = [
+            (
+                int.from_bytes(data[i : i + 3], byteorder="little", signed=True),
+                int.from_bytes(data[i + 3 : i + 6], byteorder="little", signed=True),
+                int.from_bytes(data[i + 6 : i + 9], byteorder="little", signed=True),
+            )
+            for i in range(10, len(data), 9)
+        ]
+    return constants.ACCData(timestamp=timestamp, data=acc_data)
+
+
+def parse_bluetooth_data(
+    data: List[int],
+) -> Union[constants.ECGData, constants.ACCData]:
+    """Parse Bluetooth data and return the appropriate data type."""
+    try:
+        data_type_index = data[0]
+        data_type = constants.PMD_MEASUREMENT_TYPES[data_type_index]
+        timestamp = (
+            int.from_bytes(data[1:9], byteorder="little") + constants.TIMESTAMP_OFFSET
+        )
+        frame_type = data[9]
+
+        if data_type == "ECG":
+            return parse_ecg_data(data, timestamp)
+        elif data_type == "ACC":
+            return parse_acc_data(data, timestamp, frame_type)
+        else:
+            raise ValueError(f"Unsupported data type: {data_type}")
+    except IndexError as e:
+        raise ValueError(
+            "Failed to parse Bluetooth data: insufficient data length"
+        ) from e
+
+
+def parse_heartrate_data(data: bytearray) -> constants.HRData:
+    """Parse heart rate data from a bytearray."""
+    try:
+        heartrate = int.from_bytes(data[1:2], byteorder="little", signed=False)
+        rr_intervals = [
+            int.from_bytes(data[i : i + 2], byteorder="little", signed=False)
+            / 1024.0
+            * 1024.0
+            for i in range(2, len(data), 2)
+        ]
+        return constants.HRData(heartrate, rr_intervals)
+    except IndexError as e:
+        raise ValueError(
+            "Failed to parse heart rate data: insufficient data length"
+        ) from e

polar_python-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Zachary Liu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

polar_python-0.0.1.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.1
+Name: polar-python
+Version: 0.0.1
+Summary: polar-python is a Python library for connecting to Polar devices via Bluetooth Low Energy (BLE) using Bleak. It allows querying device capabilities (e.g., ECG, ACC, PPG), exploring configurable options, and streaming parsed data through callback functions.
+Home-page: https://github.com/zHElEARN/polar-python
+Author: Zhe_Learn
+Author-email: personal@zhelearn.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bleak
+
+# polar-python
+
+`polar-python` is a Python library designed for seamless integration with Polar devices using Bluetooth Low Energy (BLE) through the Bleak library. With `polar-python`, you can easily connect to Polar devices, query supported functionalities such as ECG, ACC, and PPG, explore configurable options and their possible values, and start data streaming to receive parsed binary data through callback functions.
+
+## Features
+
+-   **Connect to Polar Devices**: Use BLE to connect to Polar devices.
+-   **Query Device Capabilities**: Discover supported functionalities like ECG, ACC, and PPG.
+-   **Explore Configurable Options**: Query and set measurement settings for each feature.
+-   **Stream Data**: Start data streaming and receive parsed binary data via callback functions.
+
+## Installation
+
+Since `polar-python` is not yet available on PyPI, you can install it locally by following these steps:
+
+1. Clone the repository:
+
+    ```sh
+    git clone https://github.com/yourusername/polar-python.git
+    ```
+
+2. Navigate to the project directory:
+
+    ```sh
+    cd polar-python
+    ```
+
+3. Install the package using pip:
+
+    ```sh
+    pip install .
+    ```
+
+## Usage
+
+Below is an example of how to use `polar-python` to connect to a Polar device, query its features, set measurement settings, and start data streaming.
+
+### Step 1: Import Libraries and Initialize Console
+
+```python
+import asyncio
+from bleak import BleakScanner
+from polar_python import PolarDevice, MeasurementSettings, SettingType, ECGData, ACCData
+```
+
+### Step 2: Define Data Callback Function
+
+```python
+def data_callback(data: Union[ECGData, ACCData]):
+    """
+    Callback function to handle incoming data from the Polar device.
+
+    Args:
+        data (Union[ECGData, ACCData]): The data received from the Polar device.
+    """
+```
+
+### Step 3: Define Main Function to Connect to Polar Device
+
+```python
+async def main():
+    """
+    Main function to connect to a Polar device, query its features,
+    set measurement settings, and start data streaming.
+    """
+    # Find the Polar H10 device
+    device = await BleakScanner.find_device_by_filter(
+        lambda bd, ad: bd.name and "Polar H10" in bd.name, timeout=5
+    )
+    if device is None:
+        return
+```
+
+### Step 4: Connect to Polar Device and Query Features
+
+```python
+    # Establish connection to the Polar device
+    async with PolarDevice(device, data_callback) as polar_device:
+        # Query available features
+        available_features = await polar_device.available_features()
+
+        # Query and print stream settings for each feature
+        for feature in available_features:
+            settings = await polar_device.request_stream_settings(feature)
+```
+
+### Step 5: Define and Start Data Streams
+
+```python
+        # Define ECG measurement settings
+        ecg_settings = MeasurementSettings(
+            measurement_type="ECG",
+            settings=[
+                SettingType(type="SAMPLE_RATE", array_length=1, values=[130]),
+                SettingType(type="RESOLUTION", array_length=1, values=[14]),
+            ],
+        )
+
+        # Define ACC measurement settings
+        acc_settings = MeasurementSettings(
+            measurement_type="ACC",
+            settings=[
+                SettingType(type="SAMPLE_RATE", array_length=1, values=[25]),
+                SettingType(type="RESOLUTION", array_length=1, values=[16]),
+                SettingType(type="RANGE", array_length=1, values=[2]),
+            ],
+        )
+
+        # Start data streams for ECG and ACC
+        await polar_device.start_stream(ecg_settings)
+        await polar_device.start_stream(acc_settings)
+
+        # Keep the stream running for 120 seconds
+        await asyncio.sleep(120)
+```
+
+### Step 6: Run the Main Function
+
+```python
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Acknowledgements
+
+-   [Bleak](https://github.com/hbldh/bleak) - BLE library for Python.
+-   [Rich](https://github.com/Textualize/rich) - Python library for rich text and beautiful formatting in the terminal.
+-   [bleakheart](https://github.com/fsmeraldi/bleakheart) - For providing inspiration and valuable insights.
+-   [Polar BLE SDK](https://github.com/polarofficial/polar-ble-sdk) - For providing official BLE SDK and documentation for Polar devices.

polar_python-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+polar_python/__init__.py,sha256=Fbic2HAqyswlP1NYVg8fYHX6s0ydpZuo3KEJBlMSpOE,238
+polar_python/constants.py,sha256=-rgr_lJ2YjLCPx7ClI522oRMjdJ5o3f8uMODj3h3-u4,1947
+polar_python/device.py,sha256=6kv29xO9NNXjj_y56TZR0dnW8MaFg-nA5gEtO_dSLrQ,6592
+polar_python/exceptions.py,sha256=W_ijsakQDNqPmmFkA_xj6y7I2h38tvV0obpH5FaJvVQ,1907
+polar_python/utils.py,sha256=VvaN_6fSRAlppjcRw8MghIY8rskWldpkWATJbhQi11g,5972
+polar_python-0.0.1.dist-info/LICENSE,sha256=0GAl0AmKuCcFbLXj8gfjjdKOD_bLyyJFTwNG2VkG_E4,1068
+polar_python-0.0.1.dist-info/METADATA,sha256=LZutQ_aZQ6rJyH2WYsHCaMv-NIfFrIX4vjt8NT7nH-E,5262
+polar_python-0.0.1.dist-info/WHEEL,sha256=rWxmBtp7hEUqVLOnTaDOPpR-cZpCDkzhhcBce-Zyd5k,91
+polar_python-0.0.1.dist-info/top_level.txt,sha256=Gj46AvJ0ljNKmSSJGdOcnm49yH391rcZW80AABcibhA,13
+polar_python-0.0.1.dist-info/RECORD,,

polar_python-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (71.0.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

polar_python-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+polar_python