python-igps-ble 0.1.0__py3-none-any.whl → 0.3.4__py3-none-any.whl

igps_ble/__init__.py

@@ -1,7 +1,18 @@
 """Pure-Python BLE library for the iGPSPORT iGS10S cycling computer."""
 
-from .models import IGPSDeviceState
+from .client import IGPSClient, IGPSCommandError, IGPSSession, read_state, set_profile
+from .models import Activity, IGPSDeviceState, UserProfile
 
-__version__ = "0.1.0"
+__version__ = "0.3.4"
 
-__all__ = ["IGPSDeviceState", "__version__"]
+__all__ = [
+    "Activity",
+    "IGPSClient",
+    "IGPSCommandError",
+    "IGPSDeviceState",
+    "IGPSSession",
+    "UserProfile",
+    "__version__",
+    "read_state",
+    "set_profile",
+]

igps_ble/__main__.py

@@ -20,11 +20,8 @@ async def _scan(timeout: float) -> None:
 
 async def _info(address: str) -> None:
     state = await IGPSClient(address).async_read_state()
-    print(f"Endereço:     {state.address}")
-    print(f"Modelo:       {state.model}")
-    print(f"Firmware:     {state.firmware}")
-    print(f"Fabricante:   {state.manufacturer}")
-    print(f"Bateria:      {state.battery_level}%")
+    for name in state.__slots__:
+        print(f"{name:17} {getattr(state, name)}")
 
 
 def main() -> None:
@@ -32,7 +29,7 @@ def main() -> None:
     sub = parser.add_subparsers(dest="cmd", required=True)
     p_scan = sub.add_parser("scan", help="Procura aparelhos iGPSPORT por perto")
     p_scan.add_argument("--timeout", type=float, default=10.0)
-    p_info = sub.add_parser("info", help="Conecta e lê bateria/device-info")
+    p_info = sub.add_parser("info", help="Conecta e lê tudo que o aparelho expõe")
     p_info.add_argument("address")
 
     args = parser.parse_args()

igps_ble/client.py

@@ -1,13 +1,20 @@
-"""Client async que conecta no iGS10S e lê as characteristics em escopo.
+"""I/O BLE do iGS10S: device-info SIG + protocolo protobuf proprietário.
 
-Único módulo que abre conexão BLE. Aceita um BleakClient já criado (ou um
-BLEDevice) — útil pra reaproveitar a conexão do bleak-retry-connector no HA.
+Único módulo que fala com o rádio. As funções aceitam um ``BleakClient`` já
+conectado — o HA passa o do bleak-retry-connector; a CLI usa ``IGPSClient``.
 """
 
 from __future__ import annotations
 
+import asyncio
+import logging
+import struct
+from dataclasses import replace
+from datetime import datetime, timedelta
+
 from bleak import BleakClient
 
+from . import protocol as p
 from .const import (
     BATTERY_LEVEL_UUID,
     FIRMWARE_REVISION_UUID,
@@ -16,12 +23,498 @@ from .const import (
     MODEL_NUMBER_UUID,
     SOFTWARE_REVISION_UUID,
 )
-from .models import IGPSDeviceState
+from .models import Activity, IGPSDeviceState, UserProfile
 from .parser import decode_device_string, parse_battery_level
 
+_LOGGER = logging.getLogger(__name__)
+
+# Epoch FIT (1989-12-31 00:00). O aparelho guarda horário *local* nessa base.
+FIT_EPOCH = datetime(1989, 12, 31)
+CYCLING_STATUS = {0: "idle", 1: "recording", 2: "paused"}
+RIDE_FIELDS = {
+    1: "speed", 2: "avg_speed", 3: "riding_time", 4: "distance", 5: "cadence",
+    6: "heart_rate", 7: "avg_heart_rate", 8: "power", 9: "total_ascent",
+    10: "avg_rise", 11: "altitude", 12: "slope", 13: "max_speed",
+    14: "max_heart_rate", 15: "avg_cadence", 16: "max_cadence",
+    17: "avg_power", 18: "max_power", 19: "course",
+}  # fmt: skip
+
+
+class IGPSCommandError(Exception):
+    """O aparelho respondeu com ACK de erro (``DeviceReturnStatus``)."""
+
+    def __init__(self, status: int) -> None:
+        super().__init__(f"device returned status {status}")
+        self.status = status
+
+
+def fit_time(seconds: int) -> datetime:
+    return FIT_EPOCH + timedelta(seconds=seconds)
+
+
+def _double(raw: int) -> float:
+    return struct.unpack("<d", raw.to_bytes(8, "little"))[0]
+
+
+def _first(msg: dict, key: int, default=None):
+    return msg.get(key, [default])[0]
+
+
+class IGPSSession:
+    """Request/response sobre os canais NUS (um comando por vez)."""
+
+    def __init__(self, client: BleakClient) -> None:
+        self._client = client
+        self._buffer = bytearray()
+        self._frames: asyncio.Queue[tuple[p.Header, bytes]] = asyncio.Queue()
+        self._lock = asyncio.Lock()
+
+    @property
+    def client(self) -> BleakClient:
+        return self._client
+
+    async def start(self) -> None:
+        for char in (p.DATA_TX, p.THIRD_TX):
+            await self._client.start_notify(char, self._on_data)
+        await self._client.start_notify(p.CONTROL_TX, self._on_control)
+
+    def _on_data(self, _char, data: bytearray) -> None:
+        self._buffer += data
+
+    def _on_control(self, _char, data: bytearray) -> None:
+        header = p.parse_header(bytes(data))
+        if header is None:
+            return
+        payload = b""
+        if header.kind == p.FRAME_HEADER:
+            payload = bytes(self._buffer)
+            self._buffer.clear()
+        self._frames.put_nowait((header, payload))
+
+    async def send(
+        self,
+        service: int,
+        op: int,
+        payload: bytes,
+        sub: int = 0xFF,
+        channel: str = p.DATA_RX,
+    ) -> None:
+        """Escreve payload + header. Descarta frames antigos ainda na fila."""
+        while not self._frames.empty():
+            self._frames.get_nowait()
+        self._buffer.clear()
+        # O firmware só lê 20 B por pacote (MTU padrão); o app fatia igual.
+        for i in range(0, len(payload), p.PACKET_SIZE):
+            chunk = payload[i : i + p.PACKET_SIZE]
+            await self._client.write_gatt_char(channel, chunk, response=True)
+        await self._client.write_gatt_char(
+            p.CONTROL_RX, p.build_header(service, op, payload, sub), True
+        )
+
+    async def receive(
+        self, service: int, timeout: float = 5.0
+    ) -> tuple[p.Header, bytes]:
+        """Próximo frame do ``service`` (pushes de outros serviços são ignorados).
+
+        ACK com status != 0 vira ``IGPSCommandError``.
+        """
+        async with asyncio.timeout(timeout):
+            while True:
+                header, payload = await self._frames.get()
+                if header.service != service:
+                    continue
+                if header.kind == p.FRAME_ACK and header.status != 0:
+                    raise IGPSCommandError(header.status)
+                return header, payload
+
+    async def ack(self, service: int, op: int, status: int = 0) -> None:
+        await self._client.write_gatt_char(
+            p.CONTROL_RX, p.build_ack(service, op, status), True
+        )
+
+    async def request(
+        self,
+        service: int,
+        op: int,
+        payload: bytes,
+        sub: int = 0xFF,
+        channel: str = p.DATA_RX,
+        timeout: float = 10.0,
+    ) -> dict[int, list]:
+        """Envia e devolve a resposta decodificada (``{}`` para um ACK de SET)."""
+        async with self._lock:
+            await self.send(service, op, payload, sub, channel)
+            return p.decode((await self.receive(service, timeout))[1])
+
+    async def simple(self, service: int, op: int, extra=(), **kw) -> dict[int, list]:
+        """Mensagem padrão ``{1: service, 2: op, ...}``."""
+        payload, _ = p.request(service, op, extra)
+        return await self.request(service, op, payload, **kw)
+
+
+# ------------------------------------------------------------------- reads
+
+
+async def _sig(client: BleakClient, uuid: str) -> str | None:
+    if client.services.get_characteristic(uuid) is None:
+        return None
+    try:
+        return decode_device_string(await client.read_gatt_char(uuid))
+    except Exception:  # noqa: BLE001 - char some/erra => ausente
+        return None
+
+
+async def _sig_battery(client: BleakClient) -> int | None:
+    if client.services.get_characteristic(BATTERY_LEVEL_UUID) is None:
+        return None
+    try:
+        return parse_battery_level(await client.read_gatt_char(BATTERY_LEVEL_UUID))
+    except Exception:  # noqa: BLE001
+        return None
+
+
+async def _read_protocol(s: IGPSSession) -> dict:
+    """Cada consulta é independente: falha numa não derruba as outras."""
+    out: dict = {}
+
+    async def attempt(fn):
+        try:
+            await fn()
+        except (IGPSCommandError, TimeoutError, ValueError) as err:
+            _LOGGER.debug("consulta %s falhou: %r", fn.__name__, err)
+
+    async def battery():
+        msg = p.decode(_first(await s.simple(p.Service.FACTORY, 6), 6, b""))
+        out["battery_voltage"] = _first(msg, 1, 0) / 1000 or None
+        out["battery_level"] = _first(msg, 2)
+
+    async def serial():
+        sn = p.decode(_first(await s.simple(p.Service.FACTORY, 1), 3, b""))
+        out["serial"] = _first(sn, 1, b"").decode() or None
+
+    async def version():
+        ver = p.decode(_first(await s.simple(p.Service.DEV_VER_INFO, 2), 3, b""))
+        if (proto := _first(ver, 6)) is not None:
+            out["protocol_version"] = f"{proto // 100}.{proto % 100:02d}"
+
+    async def memory():
+        mem = p.decode(_first(await s.simple(p.Service.FACTORY, 5), 5, b""))
+        out["memory_total"], out["memory_free"] = _first(mem, 1), _first(mem, 2)
+
+    async def sensors():
+        for raw in (await s.simple(p.Service.FACTORY, 4)).get(4, []):
+            sensor = p.decode(raw)
+            kind, data = _first(sensor, 1), _first(sensor, 2, 0)
+            if kind == 2 and data:  # RTC
+                out["device_time"] = fit_time(data)
+            elif kind == 4:  # TEM, décimos de °C
+                out["temperature"] = p.int32(data) / 10
+
+    async def status():
+        msg = await s.simple(p.Service.DEV_STATUS, 1)
+        cyc = p.decode(_first(msg, 3, b""))
+        out["cycling_status"] = CYCLING_STATUS.get(_first(cyc, 1, 0))
+        if start := _first(cyc, 2):
+            out["cycling_start"] = fit_time(start)
+        gps = p.decode(_first(msg, 4, b""))
+        if 1 in gps and 2 in gps:
+            out["latitude"] = round(_double(gps[1][0]), 6)
+            out["longitude"] = round(_double(gps[2][0]), 6)
+        rt = p.decode(_first(msg, 5, b""))
+        out["ride"] = {
+            RIDE_FIELDS[k]: p.int32(v[0]) for k, v in rt.items() if k in RIDE_FIELDS
+        }
+
+    async def activities():
+        msg = await s.simple(p.Service.CYCLING_DATA, 1, channel=p.THIRD_RX, timeout=20)
+        items = (p.decode(raw) for raw in msg.get(3, []))
+        out["activities"] = tuple(
+            sorted(
+                (
+                    Activity(
+                        _first(i, 1, 0), fit_time(_first(i, 1, 0)), _first(i, 2, 0)
+                    )
+                    for i in items
+                ),
+                key=lambda a: a.start,
+                reverse=True,
+            )
+        )
+
+    for fn in (battery, serial, version, memory, sensors, status, activities):
+        await attempt(fn)
+    return out
+
+
+async def read_state(
+    client: BleakClient,
+    address: str,
+    name: str = "iGS10S",
+    rssi: int | None = None,
+    session: IGPSSession | None = None,
+) -> IGPSDeviceState:
+    """Lê device-info SIG + tudo que o protocolo proprietário responde.
+
+    Passe ``session`` (já iniciada) para reaproveitar a conexão em comandos.
+    """
+    firmware = await _sig(client, SOFTWARE_REVISION_UUID) or await _sig(
+        client, FIRMWARE_REVISION_UUID
+    )
+    state = IGPSDeviceState(
+        address=address,
+        name=name,
+        rssi=rssi,
+        battery_level=await _sig_battery(client),
+        model=await _sig(client, MODEL_NUMBER_UUID),
+        firmware=firmware,
+        hardware=await _sig(client, HARDWARE_REVISION_UUID),
+        manufacturer=await _sig(client, MANUFACTURER_NAME_UUID),
+    )
+    if session is None:
+        session = IGPSSession(client)
+        try:
+            await session.start()
+        except Exception:  # noqa: BLE001 - aparelho sem NUS => só SIG
+            return state
+    return replace(state, **await _read_protocol(session))
+
+
+# ---------------------------------------------------------------- commands
+
+
+async def set_profile(session: IGPSSession, profile: UserProfile) -> None:
+    """Grava o perfil inteiro (USER_CONFIG/SET).
+
+    O iGS10S aceita o SET mas o GET devolve sempre zeros, então não dá pra
+    fazer read-modify-write: quem chama guarda o perfil. Campo ausente = 0.
+    ``time_zone_s`` define o fuso do relógio (que vem do GPS).
+    """
+    data = [
+        (1, profile.sex),
+        (2, round(profile.weight_kg * 10)),
+        (3, profile.age),
+        (4, profile.height_cm),
+        (5, profile.wheel_mm),
+        (6, round(profile.bike_weight_kg * 10)),
+        (7, profile.time_zone_s),
+    ]
+    await session.simple(p.Service.USER_CONFIG, 1, [(3, data)])
+
+
+async def download_activity(
+    session: IGPSSession,
+    activity_id: int,
+    size: int | None = None,
+    timeout: float = 30.0,
+    attempts: int = 3,
+) -> bytes:
+    """Baixa o ``.fit`` de uma atividade (CYCLING_DATA/FILE_GET no ch3).
+
+    O aparelho manda pedaços de ~4 KB; cada um é confirmado (ACK 0) ou pedido
+    de novo (ACK 1) se o CRC/tamanho não bater — igual ao app. Com ``size``
+    (da lista de atividades), um arquivo incompleto é baixado de novo.
+    """
+    for attempt in range(attempts):
+        data = await _download_once(session, activity_id, timeout)
+        if size is None or len(data) == size:
+            return data
+        _LOGGER.debug(
+            "fit %s incompleto (%d de %d B), tentativa %d",
+            activity_id, len(data), size, attempt + 1,
+        )  # fmt: skip
+    raise IGPSCommandError(1)
+
+
+async def _download_once(
+    session: IGPSSession, activity_id: int, timeout: float
+) -> bytes:
+    svc, file_get, file_send = p.Service.CYCLING_DATA, 3, 4
+    payload, _ = p.request(svc, file_get, [(3, [(1, activity_id)])])
+    content = bytearray()
+    async with session._lock:
+        await session.send(svc, file_get, payload, channel=p.THIRD_RX)
+        retries = 0
+        while True:
+            header, chunk = await session.receive(svc, timeout)
+            if header.op != file_send:
+                continue
+            if len(chunk) != header.length or p.crc8(chunk) != header.payload_crc:
+                retries += 1
+                _LOGGER.debug(
+                    "fit %s: pedaço inválido (%d/%d B), reenvio %d",
+                    activity_id, len(chunk), header.length, retries,
+                )  # fmt: skip
+                if retries > 5:
+                    raise IGPSCommandError(1)
+                await session.ack(svc, file_send, status=1)
+                continue
+            retries = 0
+            msg = p.decode(chunk)
+            if p.decode(_first(msg, 3, b"")).get(1, [activity_id])[0] != activity_id:
+                raise IGPSCommandError(1)  # aparelho mandou outra atividade
+            content += _first(msg, 4, b"")
+            _LOGGER.debug(
+                "fit %s: %d B (last=%s)", activity_id, len(content), header.last
+            )
+            if header.last:
+                return bytes(content)
+            await session.ack(svc, file_send)
+
+
+# ------------------------------------------------- atividades / manutenção
+#
+# Tudo abaixo segue o app (``SyncActivityDelegate``, ``FactorySettingsDelegate``,
+# ``PairBindingDelegate``, ``FirmwareUpdateDelegate``). Vários são comandos de
+# bancada de fábrica sem tela no app: os nomes vêm dos enums do protobuf.
+
+# Factory.CONTROL_CMD_TYPE (FACTORY/CONTROL_SET).
+CONTROL = {
+    "enter_check": 1,  # modo de teste de fábrica
+    "lock": 2,
+    "format": 16,  # formata a memória (apaga atividades)
+    "low_level_format": 17,
+    "reset_settings": 18,  # PARA_RESET: volta ajustes ao padrão
+    "factory_reset": 19,
+    "temperature_log": 32,
+    "voltage_log": 33,
+    "ant_log": 34,
+}
+# Factory.GPS_CONTROL_CMD_TYPE (FACTORY/GPS_CONTROL_CMD_SET).
+GPS_COMMAND = {"power": 1, "cold_start": 2, "power_save": 3, "gnss": 4}
+# Factory.GNSS_TYPE — bitmask para FACTORY/GPS_GNSS_SET.
+GNSS = {
+    "gps": 1, "beidou": 2, "glonass": 4, "qzss": 8,
+    "sbas": 16, "galileo": 32, "imes": 64,
+}  # fmt: skip
+# Factory.GPS_DYNAMIC_TYPE (modelo dinâmico do receptor).
+GPS_DYNAMIC = {
+    "portable": 1, "stationary": 2, "pedestrian": 3, "automotive": 4, "sea": 5,
+    "airborne_1g": 6, "airborne_2g": 7, "airborne_4g": 8, "wrist": 9, "bike": 10,
+}  # fmt: skip
+# Factory.FILTER_TYPE (FACTORY/FILTER_SET).
+FILTERS = {
+    "smart_save": 1, "speed": 2, "cadence": 3, "heart_rate": 4,
+    "gps_icon": 5, "ant_icon": 6,
+}  # fmt: skip
+# Comandos que podem reiniciar o aparelho antes de responder.
+_REBOOTING = {"format", "low_level_format", "reset_settings", "factory_reset"}
+
+
+async def command(
+    session: IGPSSession,
+    service: int,
+    op: int,
+    fields=(),
+    sub: int = 0xFF,
+    channel: str = p.DATA_RX,
+    timeout: float = 10.0,
+) -> dict[int, list]:
+    """Comando cru: ``{1: service, 2: op, *fields}`` — para o que não tem helper."""
+    return await session.simple(
+        service, op, list(fields), sub=sub, channel=channel, timeout=timeout
+    )
+
+
+async def delete_activity(session: IGPSSession, activity_id: int) -> None:
+    """Apaga uma atividade (CYCLING_DATA/FILE_DEL no ch3)."""
+    await session.simple(
+        p.Service.CYCLING_DATA, 5, [(3, [(1, activity_id)])], channel=p.THIRD_RX
+    )
+
+
+async def delete_all_activities(session: IGPSSession) -> None:
+    """Apaga todas as atividades (CYCLING_DATA/ALL_DEL no ch3)."""
+    await session.simple(p.Service.CYCLING_DATA, 6, channel=p.THIRD_RX)
+
+
+async def _factory(session: IGPSSession, op: int, field: int, data, **kw) -> None:
+    await session.simple(p.Service.FACTORY, op, [(field, data)], **kw)
+
+
+async def factory_control(session: IGPSSession, cmd: str, status: int = 1) -> None:
+    """FACTORY/CONTROL_SET: format, factory_reset, reset_settings, lock, logs…
+
+    Os que reiniciam o aparelho podem não responder: timeout conta como enviado.
+    """
+    try:
+        await _factory(session, 23, 8, [(1, CONTROL[cmd]), (2, status)], timeout=10)
+    except TimeoutError:
+        if cmd not in _REBOOTING:
+            raise
+
+
+async def gps_control(session: IGPSSession, cmd: str, status: int = 1) -> None:
+    """Liga/desliga GPS (``power``), ``cold_start``, ``power_save``, ``gnss``."""
+    await _factory(session, 16, 14, [(1, GPS_COMMAND[cmd]), (2, status)])
+
+
+async def set_gnss(session: IGPSSession, systems) -> None:
+    """Constelações ativas, ex. ``{"gps", "glonass", "galileo"}``."""
+    mask = 0
+    for name in systems:
+        mask |= GNSS[name]
+    await _factory(session, 18, 15, [(1, mask)])
+
+
+async def set_gps_dynamic(session: IGPSSession, mode: str) -> None:
+    await _factory(session, 20, 16, [(1, GPS_DYNAMIC[mode])])
+
+
+async def set_gps_position(
+    session: IGPSSession, latitude: float, longitude: float
+) -> None:
+    """Posição de referência (ajuda o primeiro fix)."""
+    await _factory(session, 8, 9, [(1, float(latitude)), (2, float(longitude))])
+
+
+async def set_power_save_time(session: IGPSSession, value: int) -> None:
+    """FACTORY/POWER_SAVE_TIME_SET (valor cru do firmware)."""
+    await _factory(session, 11, 11, [(1, value)])
+
+
+async def set_sun_time(session: IGPSSession, sunrise: int, sunset: int) -> None:
+    """FACTORY/SUN_TIME_SET (valores crus; usados no backlight automático)."""
+    await _factory(session, 9, 10, [(1, sunrise), (2, sunset)])
+
+
+async def set_filter(session: IGPSSession, name: str, enabled: bool) -> None:
+    await _factory(session, 14, 13, [(1, FILTERS[name]), (2, int(enabled))])
+
+
+async def set_rtc(session: IGPSSession, local: datetime) -> None:
+    """FACTORY/RTC_SET. O iGS10S confirma mas o GPS sobrescreve a hora."""
+    await _factory(session, 12, 12, [(1, int((local - FIT_EPOCH).total_seconds()))])
+
+
+async def simulate_activities(session: IGPSSession, count: int, size: int) -> None:
+    """FACTORY/SIM_FIT_SET: gera atividades .fit falsas (teste de fábrica)."""
+    await _factory(session, 7, 7, [(1, count), (2, size)])
+
+
+async def set_serial(session: IGPSSession, serial: str) -> None:
+    """FACTORY/SN_SET: regrava o número de série."""
+    await _factory(session, 3, 3, [(1, serial)])
+
+
+async def unbond(session: IGPSSession) -> None:
+    """BLE/UNBOND: desfaz o vínculo com o app (``sendCancelBonding``)."""
+    await session.simple(p.Service.BLE, 4)
+
+
+async def enter_dfu(session: IGPSSession) -> None:
+    """FIRMWARE/BLE_UPDATE: reinicia no bootloader Nordic DFU.
+
+    Lá ele espera um .zip de firmware (ex.: nRF Connect / nrfutil). Costuma
+    reiniciar sem responder, então timeout conta como enviado.
+    """
+    try:
+        await session.simple(p.Service.FIRMWARE, 5, timeout=5)
+    except TimeoutError:
+        pass
+
 
 class IGPSClient:
-    """Lê presença/bateria/device-info de um iGS10S via BLE."""
+    """Conveniência p/ CLI: abre a conexão, lê tudo e desconecta."""
 
     def __init__(
         self, address: str, name: str = "iGS10S", rssi: int | None = None
@@ -31,39 +524,5 @@ class IGPSClient:
         self._rssi = rssi
 
     async def async_read_state(self) -> IGPSDeviceState:
-        """Conecta, lê o que o aparelho expõe, e devolve o snapshot."""
         async with BleakClient(self._address) as client:
-            battery = await self._read(client, BATTERY_LEVEL_UUID)
-            model = await self._read(client, MODEL_NUMBER_UUID)
-            # O iGS10S expõe o firmware na Software Revision (0x2A28); outros
-            # aparelhos usam a Firmware Revision (0x2A26). Tentamos as duas.
-            firmware = await self._read(client, SOFTWARE_REVISION_UUID)
-            if firmware is None:
-                firmware = await self._read(client, FIRMWARE_REVISION_UUID)
-            hardware = await self._read(client, HARDWARE_REVISION_UUID)
-            manufacturer = await self._read(client, MANUFACTURER_NAME_UUID)
-
-        return IGPSDeviceState(
-            address=self._address,
-            name=self._name,
-            rssi=self._rssi,
-            battery_level=parse_battery_level(battery) if battery is not None else None,
-            model=decode_device_string(model) if model is not None else None,
-            firmware=decode_device_string(firmware) if firmware is not None else None,
-            hardware=decode_device_string(hardware) if hardware is not None else None,
-            manufacturer=(
-                decode_device_string(manufacturer)
-                if manufacturer is not None
-                else None
-            ),
-        )
-
-    @staticmethod
-    async def _read(client: BleakClient, uuid: str) -> bytes | None:
-        """Lê a char se ela existir; None se o aparelho não a expõe."""
-        if client.services.get_characteristic(uuid) is None:
-            return None
-        try:
-            return await client.read_gatt_char(uuid)
-        except Exception:  # noqa: BLE001 - char some/erra => trata como ausente
-            return None
+            return await read_state(client, self._address, self._name, self._rssi)

igps_ble/models.py

@@ -2,15 +2,37 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from datetime import datetime
+
+
+@dataclass(frozen=True, slots=True)
+class UserProfile:
+    """``user_config_data_msg`` (serviço USER_CONFIG). Unidades já convertidas."""
+
+    sex: int = 1  # 1 = masculino, 0 = feminino (``isGendar`` no app)
+    weight_kg: float = 0.0
+    age: int = 0
+    height_cm: int = 0
+    wheel_mm: int = 0
+    bike_weight_kg: float = 0.0
+    time_zone_s: int = 0
+
+
+@dataclass(frozen=True, slots=True)
+class Activity:
+    """Uma atividade gravada no aparelho (lista do serviço CYCLING_DATA)."""
+
+    id: int  # timestamp FIT cru — identifica a atividade nos comandos
+    start: datetime  # horário local do aparelho (naive)
+    size: int  # bytes do .fit
 
 
 @dataclass(frozen=True, slots=True)
 class IGPSDeviceState:
     """Snapshot do que a lib conseguiu ler do aparelho.
 
-    Campos opcionais ficam None quando o aparelho não expõe a characteristic
-    correspondente (ex.: sem Battery Service => battery_level None).
+    Campos opcionais ficam None quando o aparelho não expõe/responde o dado.
     """
 
     address: str
@@ -21,3 +43,17 @@ class IGPSDeviceState:
     firmware: str | None = None
     hardware: str | None = None
     manufacturer: str | None = None
+    # --- protocolo proprietário (protobuf no Nordic UART) ---
+    battery_voltage: float | None = None  # V
+    serial: str | None = None
+    protocol_version: str | None = None
+    memory_total: int | None = None  # unidade do aparelho (KB)
+    memory_free: int | None = None
+    temperature: float | None = None  # °C, sensor interno
+    device_time: datetime | None = None  # relógio do aparelho (local, naive)
+    cycling_status: str | None = None  # "idle" | "recording" | "paused"
+    cycling_start: datetime | None = None
+    latitude: float | None = None  # última posição GPS conhecida
+    longitude: float | None = None
+    ride: dict[str, int] = field(default_factory=dict)  # rt_data_message bruto
+    activities: tuple[Activity, ...] | None = None

igps_ble/protocol.py

@@ -0,0 +1,210 @@
+"""iGPSPORT "gen 3" protobuf-over-NUS framing (iGS10S, iGS320, iGS50S, ...).
+
+Reverse engineered from the iGPSPORT Ride Android app (com.qiwu.worldwide.ride
+8.06.46, package com.igpsport.blelib) and validated against a real iGS10S.
+
+A request is a protobuf message written to the data channel (NUS #1 RX),
+followed by a 20-byte header written to the control channel (NUS #2 RX):
+
+    [0]  0x01 (header)      [1] service        [2] sub-service (0xff = none)
+    [3]  0xff               [4] operation      [5] 0xff
+    [6]  0xff               [7:9] payload length (big-endian)
+    [9]  crc8(payload)      [10] 0x01 (end type = protobuf)
+    [11:19] 0xff * 8        [19] crc8(header[0:19])
+
+The device answers the same way (payload notifications first, then the
+header on the control channel). A 0x02 frame on the control channel is an
+ACK (``ConfirmCommand``): ``02 svc sub ff op ff ff status ...``.
+
+CRC is CRC-8/MAXIM (reflected poly 0x31, init 0).
+
+The protobuf payloads always start with ``1: service`` and ``2: operation``.
+Only a tiny wire codec is needed, so we ship one instead of protoc output.
+"""
+
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass
+
+# NUS instances. Base 6e40000X-b5a3-f393-e0a9-e50e24dccaYe.
+DATA_RX = "6e400002-b5a3-f393-e0a9-e50e24dcca9e"
+DATA_TX = "6e400003-b5a3-f393-e0a9-e50e24dcca9e"
+CONTROL_RX = "6e400002-b5a3-f393-e0a9-e50e24dcca8e"
+CONTROL_TX = "6e400003-b5a3-f393-e0a9-e50e24dcca8e"
+THIRD_RX = "6e400002-b5a3-f393-e0a9-e50e24dcca7e"
+THIRD_TX = "6e400003-b5a3-f393-e0a9-e50e24dcca7e"
+FOURTH_TX = "6e400003-b5a3-f393-e0a9-e50e24dcca6e"
+TX_CHARS = (DATA_TX, CONTROL_TX, THIRD_TX, FOURTH_TX)
+
+PACKET_SIZE = 20  # payload chunk per write (firmware ignores the rest)
+FRAME_HEADER = 0x01
+FRAME_ACK = 0x02
+
+
+class Service:
+    """``Common.service_type_index`` (subset relevant to a bike computer)."""
+
+    FIRMWARE = 4
+    CYCLING_DATA = 6
+    USER_CONFIG = 9
+    BLE = 10
+    FACTORY = 11
+    CONFIG = 12
+    DEV_STATUS = 13
+    SENSOR = 14
+    DEV_VER_INFO = 17
+
+
+# --------------------------------------------------------------------- CRC
+
+
+def crc8(data: bytes) -> int:
+    crc = 0
+    for byte in data:
+        crc ^= byte
+        for _ in range(8):
+            crc = (crc >> 1) ^ 0x8C if crc & 1 else crc >> 1
+    return crc
+
+
+def build_header(service: int, op: int, payload: bytes, sub: int = 0xFF) -> bytes:
+    head = (
+        bytes([FRAME_HEADER, service, sub, 0xFF, op, 0xFF, 0xFF])
+        + len(payload).to_bytes(2, "big")
+        + bytes([crc8(payload), 0x01])
+        + b"\xff" * 8
+    )
+    return head + bytes([crc8(head)])
+
+
+def build_ack(service: int, op: int, status: int = 0, sub: int = 0xFF) -> bytes:
+    """``ConfirmCommand``: confirma (0) ou pede reenvio (1) de um pedaço."""
+    head = bytes([FRAME_ACK, service, sub, 0xFF, op, 0xFF, 0xFF, status]) + b"\xff" * 11
+    return head + bytes([crc8(head)])
+
+
+@dataclass(frozen=True)
+class Header:
+    kind: int
+    service: int
+    sub: int
+    op: int
+    length: int
+    payload_crc: int
+    raw: bytes
+
+    @property
+    def last(self) -> bool:
+        """Último pedaço de uma transferência de arquivo (end type 3)."""
+        return self.raw[10] == 3
+
+    @property
+    def status(self) -> int:
+        """ACK status byte (``ConfirmCommand.status``)."""
+        return self.raw[7]
+
+
+def parse_header(frame: bytes) -> Header | None:
+    if len(frame) != 20 or frame[0] not in (FRAME_HEADER, FRAME_ACK):
+        return None
+    if crc8(frame[:19]) != frame[19]:
+        return None
+    return Header(
+        kind=frame[0],
+        service=frame[1],
+        sub=frame[2],
+        op=frame[4],
+        length=int.from_bytes(frame[7:9], "big"),
+        payload_crc=frame[9],
+        raw=bytes(frame),
+    )
+
+
+# ---------------------------------------------------------------- protobuf
+
+
+def _varint(value: int) -> bytes:
+    value &= (1 << 64) - 1  # negative int32/int64 -> 10-byte two's complement
+    out = bytearray()
+    while True:
+        byte = value & 0x7F
+        value >>= 7
+        if value:
+            out.append(byte | 0x80)
+        else:
+            out.append(byte)
+            return bytes(out)
+
+
+def encode(fields: list[tuple[int, int | bytes | str | list]]) -> bytes:
+    """Encode ``[(field_no, value)]``. int → varint, float → double,
+    bytes/str → len-delimited, list → nested message (same shape)."""
+    out = bytearray()
+    for number, value in fields:
+        if isinstance(value, float):  # double (wire type 1)
+            out += _varint(number << 3 | 1) + struct.pack("<d", value)
+            continue
+        if isinstance(value, bool | int):
+            out += _varint(number << 3) + _varint(int(value))
+            continue
+        if isinstance(value, list):
+            value = encode(value)
+        elif isinstance(value, str):
+            value = value.encode()
+        out += _varint(number << 3 | 2) + _varint(len(value)) + value
+    return bytes(out)
+
+
+def decode(data: bytes) -> dict[int, list]:
+    """Decode one message level into ``{field_no: [raw values]}``.
+
+    Varints come back as unsigned ints, len-delimited as bytes, fixed as int.
+    Callers decide whether bytes are a nested message (``decode`` again).
+    """
+    out: dict[int, list] = {}
+    i = 0
+    while i < len(data):
+        key, i = _read_varint(data, i)
+        number, wire = key >> 3, key & 7
+        if wire == 0:
+            value, i = _read_varint(data, i)
+        elif wire == 2:
+            size, i = _read_varint(data, i)
+            value, i = bytes(data[i : i + size]), i + size
+        elif wire == 5:
+            value, i = int.from_bytes(data[i : i + 4], "little"), i + 4
+        elif wire == 1:
+            value, i = int.from_bytes(data[i : i + 8], "little"), i + 8
+        else:
+            raise ValueError(f"unsupported wire type {wire}")
+        out.setdefault(number, []).append(value)
+    return out
+
+
+def _read_varint(data: bytes, i: int) -> tuple[int, int]:
+    shift = result = 0
+    while True:
+        if i >= len(data):
+            raise ValueError("truncated varint")
+        byte = data[i]
+        i += 1
+        result |= (byte & 0x7F) << shift
+        if not byte & 0x80:
+            return result, i
+        shift += 7
+
+
+def int32(value: int) -> int:
+    """Reinterpret an unsigned varint as a signed int32/int64."""
+    if value >= 1 << 63:
+        return value - (1 << 64)
+    if value >= 1 << 31 and value < 1 << 32:
+        return value - (1 << 32)
+    return value
+
+
+def request(service: int, op: int, extra=(), sub: int = 0xFF) -> tuple[bytes, bytes]:
+    """Return ``(payload, header)`` for a ``{1: service, 2: op, ...}`` request."""
+    payload = encode([(1, service), (2, op), *extra])
+    return payload, build_header(service, op, payload, sub)

igps_ble/scanner.py

@@ -26,7 +26,5 @@ async def discover_devices(timeout: float = 10.0) -> list[IGPSDeviceState]:
         name = adv.local_name or device.name
         if not is_igps_device(name):
             continue
-        results.append(
-            IGPSDeviceState(address=address, name=name, rssi=adv.rssi)
-        )
+        results.append(IGPSDeviceState(address=address, name=name, rssi=adv.rssi))
     return results

python_igps_ble-0.3.4.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: python-igps-ble
+Version: 0.3.4
+Summary: Pure-Python BLE library for the iGPSPORT iGS10S cycling computer (battery, sensors, ride status, activities, profile)
+Author-email: Hudson Brendon <contato.hudsonbrendon@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/hudsonbrendon/python-igps-ble
+Project-URL: Issues, https://github.com/hudsonbrendon/python-igps-ble/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bleak>=0.22
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/igpsport-logo.png" alt="iGPSPORT" width="420">
+</p>
+
+# python-igps-ble
+
+[![CI](https://github.com/hudsonbrendon/python-igps-ble/actions/workflows/ci.yml/badge.svg)](https://github.com/hudsonbrendon/python-igps-ble/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/python-igps-ble)](https://pypi.org/project/python-igps-ble/)
+[![Python](https://img.shields.io/pypi/pyversions/python-igps-ble)](https://pypi.org/project/python-igps-ble/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Talk to an **iGPSPORT iGS10S** cycling computer over Bluetooth LE from Python —
+battery, internal sensors, ride status, stored activities, last GPS position and
+the rider/bike profile, through iGPSPORT's proprietary protobuf-over-Nordic-UART
+protocol (reverse engineered from the official app, no pairing or login needed).
+
+This library powers the
+[**iGPSPORT iGS10S Home Assistant integration**](https://github.com/hudsonbrendon/ha-igps-ble),
+but works standalone in any async Python project (or straight from the command line).
+
+> Protocol notes:
+> [`ha-igps-ble/docs/PROTOCOL.md`](https://github.com/hudsonbrendon/ha-igps-ble/blob/main/docs/PROTOCOL.md).
+
+## Features
+
+- 🔌 **Async BLE control** built on [`bleak`](https://github.com/hbldh/bleak) —
+  works on Linux, macOS, and Windows.
+- 🔍 **Discovery helper** — `discover_devices()` finds nearby iGPSPORT devices
+  (presence + RSSI).
+- 🏷️ **Device info** — manufacturer, hardware revision, firmware, serial and
+  protocol version.
+- 🔋 **Battery** — level (%) and voltage.
+- 🌡️ **Sensors** — internal temperature, free memory, device clock.
+- 🚴 **Ride status** — idle / recording / paused, live ride fields while recording,
+  last GPS position.
+- 🗂️ **Activities** — list of rides stored on the device (start time, size).
+- 💾 **`.fit` download** — `download_activity(session, id, size)` with per-chunk CRC and
+  size checks.
+- 🧹 **Maintenance** — delete one/all activities, `factory_control()` (format,
+  factory reset, settings reset, lock, logs, test mode), unbind, DFU mode.
+- 🛰️ **GPS** — `gps_control()`, `set_gnss()`, `set_gps_dynamic()`, `set_gps_position()`.
+- 🧪 **Raw** — `command(session, service, op, fields)` for anything else.
+- ⚙️ **Profile** — write rider weight/height/age/sex, wheel circumference, bike
+  weight and time zone (`set_profile`).
+- 🖥️ **CLI** — `igps-ble scan / info` for quick testing.
+
+## Requirements
+
+- Python **3.11** or newer.
+- A Bluetooth LE adapter (built-in or USB).
+- An iGPSPORT iGS10S (other iGPSPORT models exposing the same standard services
+  may also work).
+
+## Installation
+
+```bash
+pip install python-igps-ble
+```
+
+## CLI usage
+
+```bash
+igps-ble scan                      # find nearby iGPSPORT devices
+igps-ble info AA:BB:CC:DD:EE:FF     # connect and read everything
+```
+
+## Library usage
+
+```python
+import asyncio
+from igps_ble import IGPSDeviceState
+from igps_ble.scanner import discover_devices
+from igps_ble.client import IGPSClient
+
+
+async def main():
+    for dev in await discover_devices(timeout=10):
+        state: IGPSDeviceState = await IGPSClient(
+            dev.address, dev.name
+        ).async_read_state()
+        print(state.manufacturer, state.model, state.firmware, state.battery_level)
+
+
+asyncio.run(main())
+```
+
+`IGPSClient` accepts a `bleak` `BLEDevice` (preferred — e.g. from Home Assistant's
+shared scanner or a Bluetooth proxy) or a string MAC/UUID address.
+
+### API
+
+| Symbol | Description |
+|---|---|
+| `discover_devices(timeout=10.0)` | List nearby iGPSPORT devices as `IGPSDeviceState` (presence + RSSI; does not connect). |
+| `is_igps_device(local_name)` | `True` if an advertisement name matches a known iGPSPORT prefix. |
+| `IGPSClient(address, name="iGS10S", rssi=None)` | Async client; `await client.async_read_state()` connects and returns an `IGPSDeviceState`. |
+| `read_state(client, address, name, rssi, session=None)` | Read everything over an already-connected `BleakClient`. |
+| `IGPSSession(client)` | Request/response over the NUS channels; `await session.start()` once per connection. |
+| `set_profile(session, UserProfile(...))` | Write the whole rider/bike profile (the device does not report it back). |
+| `IGPSDeviceState` | Frozen dataclass with everything read (battery, sensors, ride status, GPS, activities…). |
+| `igps_ble.protocol` | Framing (20-byte header, CRC-8/MAXIM) and a tiny protobuf codec. |
+| `parse_battery_level(data)` / `decode_device_string(data)` | Pure parsers for the standard Bluetooth SIG characteristics. |
+
+## Scope
+
+| Data | Supported | Source |
+|------|-----------|--------|
+| Presence | ✅ | BLE advertisement |
+| Manufacturer / hardware / firmware | ✅ | Device Information Service `0x180A` |
+| Battery % / voltage | ✅ | FACTORY service (protobuf) |
+| Serial, memory, temperature, clock | ✅ | FACTORY service |
+| Ride status, last GPS fix, live ride fields | ✅ | DEV_STATUS service (live field units unconfirmed) |
+| Stored activity list | ✅ | CYCLING_DATA service |
+| Rider/bike profile, time zone | ✅ write-only | USER_CONFIG service |
+| `.fit` download | ✅ | CYCLING_DATA FILE_GET |
+| Delete activities, format, factory reset, GPS/factory settings, unbind, DFU | ✅ not live-tested | FACTORY / CYCLING_DATA / BLE / FIRMWARE |
+| Display/page settings, time sync | ❌ | unsupported by the iGS10S firmware |
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e ".[dev]"
+.venv/bin/pytest
+```
+
+## Credits
+
+Built to back the [`ha-igps-ble`](https://github.com/hudsonbrendon/ha-igps-ble)
+Home Assistant integration. Author [@hudsonbrendon](https://github.com/hudsonbrendon).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

python_igps_ble-0.3.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+igps_ble/__init__.py,sha256=CutdfSzl3Zl_G1xmPyfItiWlcAiiBAUJRKKoC8Qad6A,432
+igps_ble/__main__.py,sha256=GX7qDcyGKu7MwhDyhPzqe3vEwMHadg0axIQBTSbdrxU,1273
+igps_ble/client.py,sha256=BMNYH4yi7J6neDvpmAW2yBpxjq4r3a87v7atYNZjZuk,18994
+igps_ble/const.py,sha256=0PfoY4CCFypAJ4bEKyBpFLDZufB6aRZKd04IFdI35sM,1161
+igps_ble/models.py,sha256=xm7zEXypx21PnhreKpuj_xzcmhnhuTzJxFSsV4HAv_E,2010
+igps_ble/parser.py,sha256=IkY_fpODaJkXwSilkA5JzXks1VEP5MsoHjf4aOr9JtE,627
+igps_ble/protocol.py,sha256=KDtRI-EhIfLox-jrUb8u4Lrub8mJKhOCUEVQCIpdwGU,6752
+igps_ble/scanner.py,sha256=ogezk2bSMm7_Eivar-3a_O7tFn69871egWBS1lAkyaA,1063
+python_igps_ble-0.3.4.dist-info/licenses/LICENSE,sha256=4Zgd3fbLJqWSkwKA-hh1rNN6DC9tNQ3rWLX93fingOw,1071
+python_igps_ble-0.3.4.dist-info/METADATA,sha256=ZFO5UIidvuFozzcpZDCWTv9lWB8NN2Wen6NAlT2QQvE,6489
+python_igps_ble-0.3.4.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+python_igps_ble-0.3.4.dist-info/entry_points.txt,sha256=WmO3pSZ-qD2ZfHtnxxqyvUycW8LEwMFIJIC1k7oFSuY,52
+python_igps_ble-0.3.4.dist-info/top_level.txt,sha256=69O33W2-0wC37bi3yvYxMJqOVdk612_CqJYgxErMS8A,9
+python_igps_ble-0.3.4.dist-info/RECORD,,

{python_igps_ble-0.1.0.dist-info → python_igps_ble-0.3.4.dist-info}/WHEEL

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

python_igps_ble-0.3.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hudson Brendon
+
+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.

python_igps_ble-0.1.0.dist-info/METADATA

@@ -1,78 +0,0 @@
-Metadata-Version: 2.4
-Name: python-igps-ble
-Version: 0.1.0
-Summary: Pure-Python BLE library for the iGPSPORT iGS10S cycling computer (presence, battery, device info)
-Author-email: Hudson Brendon <contato.hudsonbrendon@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/hudsonbrendon/python-igps-ble
-Project-URL: Issues, https://github.com/hudsonbrendon/python-igps-ble/issues
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-Requires-Dist: bleak>=0.22
-Provides-Extra: dev
-Requires-Dist: pytest>=8; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
-Requires-Dist: ruff>=0.5; extra == "dev"
-
-# python-igps-ble
-
-Pure-Python BLE library for the **iGPSPORT iGS10S** cycling computer.
-
-Reads, over standard Bluetooth Low Energy, what the device exposes to
-third parties: **presence**, **battery level**, and **device info**
-(model / firmware / manufacturer). The proprietary `.fit` sync used by the
-official iGPSPORT app is **out of scope** (see `ha-igps-ble/docs/PROTOCOL.md`).
-
-> Built to back the [`ha-igps-ble`](https://github.com/hudsonbrendon/ha-igps-ble)
-> Home Assistant integration, but usable standalone.
-
-## Install
-
-```bash
-pip install python-igps-ble
-```
-
-## CLI
-
-```bash
-igps-ble scan                 # procura aparelhos iGPSPORT por perto
-igps-ble info AA:BB:CC:DD:EE:FF   # bateria + device-info
-```
-
-## Uso programático
-
-```python
-import asyncio
-from igps_ble import IGPSDeviceState
-from igps_ble.scanner import discover_devices
-from igps_ble.client import IGPSClient
-
-async def main():
-    for dev in await discover_devices(timeout=10):
-        state: IGPSDeviceState = await IGPSClient(dev.address, dev.name).async_read_state()
-        print(state)
-
-asyncio.run(main())
-```
-
-## Escopo
-
-| Dado | Suportado | Fonte |
-|------|-----------|-------|
-| Presença | ✅ | advertisement BLE |
-| Bateria % | ✅* | Battery Service `0x180F` |
-| Modelo / firmware | ✅* | Device Information `0x180A` |
-| Velocidade / distância / pedalada | ❌ | sync proprietário (não exposto por BLE) |
-
-\* depende de o iGS10S expor o serviço SIG correspondente — confirmado por recon.
-
-## Desenvolvimento
-
-```bash
-python -m venv .venv && .venv/bin/pip install -e ".[dev]"
-.venv/bin/pytest
-```
-
-## Licença
-
-MIT

python_igps_ble-0.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-igps_ble/__init__.py,sha256=eeV-l5_0sdRkAEPeB9uUUE4G2dZ-rCq1T6y1UJhDWbk,178
-igps_ble/__main__.py,sha256=mCoZbDckv8FDd613fWJE0pTaCVwv2fG3Snn2V6KhWGY,1414
-igps_ble/client.py,sha256=f66p39IP5g-UVkOn30JACZrjOOPuQs5IGJ6_7g665gg,2728
-igps_ble/const.py,sha256=0PfoY4CCFypAJ4bEKyBpFLDZufB6aRZKd04IFdI35sM,1161
-igps_ble/models.py,sha256=H6UNnnMfVovc0EsqYHyC0oIPPvnJ99i8Vi9y_SyWL-I,620
-igps_ble/parser.py,sha256=IkY_fpODaJkXwSilkA5JzXks1VEP5MsoHjf4aOr9JtE,627
-igps_ble/scanner.py,sha256=aJj3bE_K9ky9fJKicKLrRoWf1YSeXZRRsGghpzBauP4,1085
-python_igps_ble-0.1.0.dist-info/METADATA,sha256=QX_XkHtYvVZV8Dg7aNWzuIYMCo7P9bvi8z1aV-QHjcs,2253
-python_igps_ble-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-python_igps_ble-0.1.0.dist-info/entry_points.txt,sha256=WmO3pSZ-qD2ZfHtnxxqyvUycW8LEwMFIJIC1k7oFSuY,52
-python_igps_ble-0.1.0.dist-info/top_level.txt,sha256=69O33W2-0wC37bi3yvYxMJqOVdk612_CqJYgxErMS8A,9
-python_igps_ble-0.1.0.dist-info/RECORD,,