python-jebao 0.1.1__tar.gz → 0.1.3__tar.gz

{python_jebao-0.1.1 → python_jebao-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jebao
-Version: 0.1.1
+Version: 0.1.3
 Summary: Python library for controlling Jebao aquarium pumps
 Home-page: https://github.com/jrigling/python-jebao
 Author: Justin Rigling

{python_jebao-0.1.1 → python_jebao-0.1.3}/jebao/__init__.py

@@ -16,7 +16,7 @@ from .const import (
     MODEL_MD44,
 )
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"
 
 __all__ = [
     "JebaoDevice",

{python_jebao-0.1.1 → python_jebao-0.1.3}/jebao/protocol.py

@@ -55,7 +55,10 @@ class JebaoProtocol:
         self._sequence = 1
         self._keepalive_task: Optional[asyncio.Task] = None
         self._passcode: Optional[bytes] = None
-        self._read_lock = asyncio.Lock()
+
+        # Locks for thread-safe operation
+        self._request_lock = asyncio.Lock()  # Serialize entire request-response cycles
+        self._read_lock = asyncio.Lock()     # Low-level read serialization
 
         # Message dispatcher
         self._message_queues: Dict[int, asyncio.Queue] = {}
@@ -360,35 +363,41 @@ class JebaoProtocol:
             JebaoConnectionError: Not connected
             JebaoTimeoutError: Request timed out
         """
-        if not self.is_connected:
-            raise JebaoConnectionError("Not connected")
-
-        # Send simple status request (0x90)
-        # Format: 00 00 00 03 04 00 00 90 02
-        # The last byte (02) requests values, and response will be message type 91 or 0x00
-        request = bytes.fromhex("0000000304000090 02")
-        _LOGGER.debug(f"Sending status request: {request.hex()}")
-        await self._send_raw(request)
-        _LOGGER.debug("Status request sent, waiting for response...")
-
-        # Read response directly (no dispatcher)
-        try:
-            response = await asyncio.wait_for(self._read_raw(), timeout=timeout)
-        except asyncio.TimeoutError as err:
-            raise JebaoTimeoutError("Status request timed out") from err
+        # Serialize requests - only one operation at a time
+        async with self._request_lock:
+            if not self.is_connected:
+                raise JebaoConnectionError("Not connected")
+
+            # Drain any unexpected leftover bytes as safety net (very short timeout)
+            # Normally padding is read explicitly, but this catches edge cases
+            await self._drain_garbage_bytes(timeout=0.01)
+
+            # Send simple status request (0x90)
+            # Format: 00 00 00 03 04 00 00 90 02
+            # The last byte (02) requests values, and response will be message type 91 or 0x00
+            request = bytes.fromhex("0000000304000090 02")
+            _LOGGER.debug(f"Sending status request: {request.hex()}")
+            await self._send_raw(request)
+            _LOGGER.debug("Status request sent, waiting for response...")
+
+            # Read response directly (no dispatcher)
+            try:
+                response = await asyncio.wait_for(self._read_raw(), timeout=timeout)
+            except asyncio.TimeoutError as err:
+                raise JebaoTimeoutError("Status request timed out") from err
 
-        _LOGGER.debug(f"Status response length: {len(response)}, data: {response.hex()[:100]}...")
+            _LOGGER.debug(f"Status response length: {len(response)}, data: {response.hex()[:100]}...")
 
-        # Note: Don't drain here - pump may send unsolicited updates that we shouldn't consume
+            # Note: Don't drain here - pump may send unsolicited updates that we shouldn't consume
 
-        if len(response) < 10:
-            raise JebaoCommandError(f"Invalid status response: too short ({len(response)} bytes)")
+            if len(response) < 10:
+                raise JebaoCommandError(f"Invalid status response: too short ({len(response)} bytes)")
 
-        # Log the message type and first few bytes for debugging
-        msg_type = response[7] if len(response) > 7 else 0
-        _LOGGER.debug(f"Status response type: 0x{msg_type:02x}, bytes 10-12: {response[10:12].hex() if len(response) > 11 else 'N/A'}")
+            # Log the message type and first few bytes for debugging
+            msg_type = response[7] if len(response) > 7 else 0
+            _LOGGER.debug(f"Status response type: 0x{msg_type:02x}, bytes 10-12: {response[10:12].hex() if len(response) > 11 else 'N/A'}")
 
-        return response
+            return response
 
     async def send_control_command(
         self,
@@ -412,48 +421,48 @@ class JebaoProtocol:
             JebaoCommandError: Command failed
             JebaoTimeoutError: Command timed out
         """
-        if not self.is_connected:
-            raise JebaoConnectionError("Not connected")
+        # Serialize requests - only one operation at a time
+        async with self._request_lock:
+            if not self.is_connected:
+                raise JebaoConnectionError("Not connected")
 
-        # Drain any garbage bytes left from previous operations
-        # This prevents garbage from corrupting the ACK read
-        await self._drain_garbage_bytes(timeout=0.05)
-
-        command = self._build_control_command(opcode1, opcode2, param1, param2)
-        _LOGGER.debug(
-            "Sending control command: opcode1=0x%02x, opcode2=0x%02x, param1=%d, param2=%d",
-            opcode1,
-            opcode2,
-            param1,
-            param2,
-        )
-        await self._send_raw(command)
-
-        # Read ACK (message type 0x94) directly
-        # The pump sends an ACK for control commands
-        try:
-            ack = await asyncio.wait_for(self._read_raw(), timeout=timeout)
-            ack_type = ack[7] if len(ack) > 7 else 0
-            _LOGGER.debug("Control command ACK received: type=0x%02x, %d bytes", ack_type, len(ack))
+            # Drain any unexpected leftover bytes as safety net (very short timeout)
+            # Normally padding is read explicitly, but this catches edge cases
+            await self._drain_garbage_bytes(timeout=0.01)
+
+            command = self._build_control_command(opcode1, opcode2, param1, param2)
+            _LOGGER.debug(
+                "Sending control command: opcode1=0x%02x, opcode2=0x%02x, param1=%d, param2=%d",
+                opcode1,
+                opcode2,
+                param1,
+                param2,
+            )
+            await self._send_raw(command)
 
-            # After ACK, pump may send unsolicited status update
-            # Try to read it with short timeout
+            # Read ACK (message type 0x94) directly
+            # The pump sends an ACK for control commands
             try:
-                status_update = await asyncio.wait_for(self._read_raw(), timeout=0.5)
-                status_type = status_update[7] if len(status_update) > 7 else 0
-                _LOGGER.info(
-                    "Pump sent unsolicited status update after control command: type=0x%02x",
-                    status_type,
-                )
-                # Drain any remaining garbage after the status update
-                await self._drain_garbage_bytes()
-            except asyncio.TimeoutError:
-                # No status update sent, that's OK
-                _LOGGER.debug("No unsolicited status update after control command")
+                ack = await asyncio.wait_for(self._read_raw(), timeout=timeout)
+                ack_type = ack[7] if len(ack) > 7 else 0
+                _LOGGER.debug("Control command ACK received: type=0x%02x, %d bytes", ack_type, len(ack))
 
-        except asyncio.TimeoutError:
-            _LOGGER.warning("Control command sent but no ACK received (pump may still process it)")
-            # Don't raise - pump may still process the command even without ACK
+                # After ACK, pump may send unsolicited status update
+                # Try to read it with short timeout
+                try:
+                    status_update = await asyncio.wait_for(self._read_raw(), timeout=0.5)
+                    status_type = status_update[7] if len(status_update) > 7 else 0
+                    _LOGGER.info(
+                        "Pump sent unsolicited status update after control command: type=0x%02x",
+                        status_type,
+                    )
+                except asyncio.TimeoutError:
+                    # No status update sent, that's OK
+                    _LOGGER.debug("No unsolicited status update after control command")
+
+            except asyncio.TimeoutError:
+                _LOGGER.warning("Control command sent but no ACK received (pump may still process it)")
+                # Don't raise - pump may still process the command even without ACK
 
     def _build_control_command(
         self, opcode1: int, opcode2: int, param1: int, param2: int
@@ -580,6 +589,8 @@ class JebaoProtocol:
             self._writer.write(data)
             await self._writer.drain()
         except Exception as err:
+            _LOGGER.error("Send failed, closing connection: %s", err)
+            await self.disconnect()
             raise JebaoConnectionError(f"Send failed: {err}") from err
 
     async def _read_raw(self) -> bytes:
@@ -606,10 +617,17 @@ class JebaoProtocol:
                 for attempt in range(max_resync_attempts):
                     if header[0:4] == b"\x00\x00\x00\x03":
                         # Valid header found
+                        if attempt > 0:
+                            # Log when we had to re-sync (shouldn't happen often now)
+                            _LOGGER.warning(
+                                "Had to re-sync message stream after %d attempt(s) - "
+                                "garbage bytes not properly drained",
+                                attempt
+                            )
                         break
 
                     # Invalid header - try to re-sync by reading one more byte
-                    _LOGGER.warning(
+                    _LOGGER.debug(
                         "Invalid header %s, attempting re-sync (attempt %d/%d)",
                         header[0:4].hex(),
                         attempt + 1,
@@ -632,12 +650,51 @@ class JebaoProtocol:
 
                 result = header + remaining
                 msg_type = result[7] if len(result) > 7 else 0
+
+                # Only message type 0x00 (extended status responses) has 129-byte padding
+                # All other message types have no padding
+                if msg_type == MSG_EXTENDED_DATA:
+                    # Read fixed padding (129 bytes) that pump sends for extended responses
+                    # The pump uses fixed-frame protocol with padding (0xee or 0x00)
+                    padding = await self._reader.readexactly(129)
+
+                    # Validate padding - should be mostly 0xee or 0x00 patterns
+                    # Check first 4 bytes and last byte
+                    padding_start = padding[0:4]
+                    padding_end = padding[-1]
+
+                    # Valid patterns: eeeeeeee or 00000000 at start, 00 at end
+                    is_valid_padding = (
+                        (padding_start == b'\xee\xee\xee\xee' or padding_start == b'\x00\x00\x00\x00')
+                        and padding_end == 0x00
+                    )
+
+                    if not is_valid_padding:
+                        _LOGGER.error(
+                            "Invalid padding detected! Start: %s, End: 0x%02x - possible protocol corruption",
+                            padding_start.hex(),
+                            padding_end
+                        )
+                        # Drain any additional garbage as fallback
+                        await self._drain_garbage_bytes(timeout=0.05)
+                        raise JebaoConnectionError(
+                            f"Protocol error: invalid padding (start={padding_start.hex()}, end=0x{padding_end:02x})"
+                        )
+
+                    _LOGGER.debug(
+                        "Read 129-byte padding frame for msg type 0x00 (start: %s, end: 0x%02x)",
+                        padding_start.hex(),
+                        padding_end
+                    )
+
                 _LOGGER.debug(
                     f"Message complete: {len(result)} bytes, type=0x{msg_type:02x}"
                 )
                 return result
             except asyncio.IncompleteReadError as err:
                 _LOGGER.error("IncompleteReadError - connection closed by peer")
+                # Mark connection as closed so reconnection can happen
+                await self.disconnect()
                 raise JebaoConnectionError("Connection closed") from err
             except JebaoConnectionError:
                 raise

{python_jebao-0.1.1 → python_jebao-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-jebao"
-version = "0.1.1"
+version = "0.1.3"
 description = "Python library for controlling Jebao aquarium pumps"
 readme = "README.md"
 license = "MIT"

{python_jebao-0.1.1 → python_jebao-0.1.3}/python_jebao.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jebao
-Version: 0.1.1
+Version: 0.1.3
 Summary: Python library for controlling Jebao aquarium pumps
 Home-page: https://github.com/jrigling/python-jebao
 Author: Justin Rigling