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

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

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

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

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

{python_jebao-0.1.3 → python_jebao-0.1.6}/jebao/device.py

@@ -34,11 +34,18 @@ class JebaoDevice:
         self.device_id = device_id
         self.model = model
 
-        self._protocol = JebaoProtocol(host, port)
+        self._protocol = JebaoProtocol(host, port, device_id=device_id)
         self._state: Optional[DeviceState] = None
         self._speed: Optional[int] = None
         self._last_update: Optional[float] = None
 
+    @property
+    def device_identifier(self) -> str:
+        """Get device identifier for logging."""
+        if self.device_id:
+            return f"[{self.device_id}]"
+        return f"[{self.host}]"
+
     @property
     def is_connected(self) -> bool:
         """Check if device is connected."""
@@ -90,7 +97,7 @@ class JebaoDevice:
             JebaoAuthenticationError: Authentication failed
         """
         await self._protocol.connect(timeout)
-        _LOGGER.info("Connected to %s (%s)", self.host, self.model or "Unknown")
+        _LOGGER.info("%s Connected (%s)", self.device_identifier, self.model or "Unknown")
 
         # Get initial status
         await self.update()
@@ -98,7 +105,7 @@ class JebaoDevice:
     async def disconnect(self) -> None:
         """Disconnect from device."""
         await self._protocol.disconnect()
-        _LOGGER.info("Disconnected from %s", self.host)
+        _LOGGER.info("%s Disconnected", self.device_identifier)
 
     @async_retry(max_attempts=3, delay=0.5)
     async def update(self, timeout: float = DEFAULT_TIMEOUT) -> None:
@@ -124,12 +131,13 @@ class JebaoDevice:
             self._speed = status["speed"]
             self._last_update = time.time()
             _LOGGER.debug(
-                "Status updated: state=%s, speed=%d%%",
+                "%s Status updated: state=%s, speed=%d%%",
+                self.device_identifier,
                 self._state.name,
                 self._speed,
             )
         else:
-            _LOGGER.warning("Failed to parse status response")
+            _LOGGER.warning("%s Failed to parse status response", self.device_identifier)
 
     async def __aenter__(self):
         """Async context manager entry."""

{python_jebao-0.1.3 → python_jebao-0.1.6}/jebao/mdp20000.py

@@ -90,7 +90,7 @@ class MDP20000Device(JebaoDevice):
             This method automatically retries up to 3 times on transient
             failures (garbage bytes, connection issues).
         """
-        _LOGGER.info("Turning on pump")
+        _LOGGER.info("%s Turning on pump", self.device_identifier)
 
         await self._protocol.send_control_command(
             CommandOpcode.TURN_ON_OFF,
@@ -115,7 +115,7 @@ class MDP20000Device(JebaoDevice):
             This method automatically retries up to 3 times on transient
             failures (garbage bytes, connection issues).
         """
-        _LOGGER.info("Turning off pump")
+        _LOGGER.info("%s Turning off pump", self.device_identifier)
 
         await self._protocol.send_control_command(
             CommandOpcode.TURN_ON_OFF,
@@ -148,7 +148,7 @@ class MDP20000Device(JebaoDevice):
                 f"Speed must be between {MIN_SPEED} and {MAX_SPEED}, got {percentage}"
             )
 
-        _LOGGER.info("Setting speed to %d%%", percentage)
+        _LOGGER.info("%s Setting speed to %d%%", self.device_identifier, percentage)
 
         await self._protocol.send_control_command(
             CommandOpcode.SET_SPEED,

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

@@ -41,15 +41,17 @@ MSG_EXTENDED_DATA = 0x00
 class JebaoProtocol:
     """Low-level protocol implementation for Jebao devices."""
 
-    def __init__(self, host: str, port: int = 12416):
+    def __init__(self, host: str, port: int = 12416, device_id: Optional[str] = None):
         """Initialize protocol handler.
 
         Args:
             host: Device IP address
             port: TCP port (default 12416)
+            device_id: Device ID for logging (optional)
         """
         self.host = host
         self.port = port
+        self.device_id = device_id
         self._reader: Optional[asyncio.StreamReader] = None
         self._writer: Optional[asyncio.StreamWriter] = None
         self._sequence = 1
@@ -68,6 +70,13 @@ class JebaoProtocol:
         # Read buffer for handling garbage bytes
         self._read_buffer = bytearray()
 
+    @property
+    def device_identifier(self) -> str:
+        """Get device identifier for logging."""
+        if self.device_id:
+            return f"[{self.device_id}]"
+        return f"[{self.host}]"
+
     @property
     def is_connected(self) -> bool:
         """Check if connection is established."""
@@ -85,7 +94,7 @@ class JebaoProtocol:
             JebaoTimeoutError: Operation timed out
         """
         try:
-            _LOGGER.debug("Connecting to %s:%d", self.host, self.port)
+            _LOGGER.debug("%s Connecting to %s:%d", self.device_identifier, self.host, self.port)
             self._reader, self._writer = await asyncio.wait_for(
                 asyncio.open_connection(self.host, self.port), timeout=timeout
             )
@@ -117,7 +126,7 @@ class JebaoProtocol:
         Raises:
             JebaoAuthenticationError: Authentication failed
         """
-        _LOGGER.debug("Starting authentication")
+        _LOGGER.debug("%s Starting authentication", self.device_identifier)
 
         # Step 1: Request passcode
         request = self._build_passcode_request()
@@ -161,7 +170,7 @@ class JebaoProtocol:
             _LOGGER.error(f"Login failed - expected type 0x{MSG_LOGIN_SUCCESS:02x} at byte 7, got 0x{response[7]:02x}")
             raise JebaoAuthenticationError("Login failed")
 
-        _LOGGER.info("Authentication successful for %s", self.host)
+        _LOGGER.info("%s Authentication successful", self.device_identifier)
 
     async def disconnect(self) -> None:
         """Disconnect from device."""
@@ -188,7 +197,7 @@ class JebaoProtocol:
                 self._writer = None
                 self._reader = None
 
-        _LOGGER.debug("Disconnected from %s", self.host)
+        _LOGGER.debug("%s Disconnected", self.device_identifier)
 
     def _start_keepalive(self) -> None:
         """Start keepalive task."""
@@ -432,7 +441,8 @@ class JebaoProtocol:
 
             command = self._build_control_command(opcode1, opcode2, param1, param2)
             _LOGGER.debug(
-                "Sending control command: opcode1=0x%02x, opcode2=0x%02x, param1=%d, param2=%d",
+                "%s Sending control command: opcode1=0x%02x, opcode2=0x%02x, param1=%d, param2=%d",
+                self.device_identifier,
                 opcode1,
                 opcode2,
                 param1,
@@ -520,14 +530,19 @@ class JebaoProtocol:
         return bytes(buffer)
 
     async def _drain_garbage_bytes(self, timeout: float = 0.1) -> None:
-        """Drain any garbage/padding bytes from the socket buffer.
+        """Drain leftover bytes and unsolicited messages from the socket buffer.
 
-        The MDP-20000 pump appears to send extra padding bytes (0xee) after
-        valid responses. This method drains those bytes to prevent them from
-        corrupting subsequent reads.
+        The MDP-20000 pump emits two things we need to consume before a request:
+        - Padding bytes (0xee / 0x00) trailing some responses
+        - Unsolicited type 0x00 status broadcasts (header + body + 129-byte padding)
+
+        If an unsolicited type 0x00 frame is found and we only consume its body,
+        the trailing 129-byte padding remains in the buffer and corrupts the next
+        read (forcing a slow byte-by-byte resync that often races the pump's
+        connection close, surfacing as IncompleteReadError).
 
         Args:
-            timeout: How long to wait for garbage bytes (default 0.1s)
+            timeout: How long to wait for bytes (default 0.1s)
         """
         if not self._reader:
             return
@@ -549,20 +564,21 @@ class JebaoProtocol:
                         continue
                     # Check if it's a valid header
                     if header[0:4] == b"\x00\x00\x00\x03":
-                        # Valid header found - this is a real message!
-                        # Put it back somehow... actually, we can't put it back easily
-                        # This is a problem - we've consumed a valid message header
-                        _LOGGER.warning(
-                            "Found valid header while draining - this shouldn't happen! "
-                            "Pump may have sent unsolicited message."
-                        )
-                        # Read the rest of this message to consume it
+                        # Pump sent an unsolicited message (e.g. periodic status broadcast).
+                        # Consume the full frame so we don't desync the stream.
                         length = header[4]
-                        remaining = await self._reader.read(length)
-                        _LOGGER.warning(
-                            "Consumed unsolicited message: type=0x%02x, %d bytes total",
-                            header[7] if len(header) > 7 else 0,
-                            len(header) + len(remaining),
+                        body = await self._reader.readexactly(length)
+                        msg_type = body[2] if len(body) > 2 else 0
+                        total = len(header) + len(body)
+                        # Type 0x00 messages carry an extra 129-byte padding frame
+                        # (same as _read_raw). Skip it or stale bytes corrupt the next read.
+                        if msg_type == MSG_EXTENDED_DATA:
+                            padding = await self._reader.readexactly(129)
+                            total += len(padding)
+                        _LOGGER.debug(
+                            "Drained unsolicited message: type=0x%02x, %d bytes total",
+                            msg_type,
+                            total,
                         )
                     else:
                         # Garbage header - log and continue draining
@@ -692,7 +708,7 @@ class JebaoProtocol:
                 )
                 return result
             except asyncio.IncompleteReadError as err:
-                _LOGGER.error("IncompleteReadError - connection closed by peer")
+                _LOGGER.error("%s IncompleteReadError - connection closed by peer", self.device_identifier)
                 # Mark connection as closed so reconnection can happen
                 await self.disconnect()
                 raise JebaoConnectionError("Connection closed") from err

{python_jebao-0.1.3 → python_jebao-0.1.6}/jebao/retry.py

@@ -41,27 +41,57 @@ def async_retry(
                     return await func(*args, **kwargs)
                 except exceptions as e:
                     if attempt == max_attempts:
+                        device_id = ""
+                        if args and hasattr(args[0], 'device_identifier'):
+                            device_id = args[0].device_identifier + " "
                         _LOGGER.error(
-                            f"{func.__name__} failed after {max_attempts} attempts: {e}"
+                            f"{device_id}{func.__name__} failed after {max_attempts} attempts: {e}"
                         )
                         raise
 
-                    # Check if error message indicates garbage issue
+                    # Check if error message indicates specific issues
                     error_msg = str(e).lower()
                     is_garbage_issue = (
                         "synchronization" in error_msg
                         or "garbage" in error_msg
                         or "invalid header" in error_msg
                     )
+                    is_not_connected = "not connected" in error_msg or "connection closed" in error_msg
+
+                    # Attempt reconnection if disconnected
+                    if is_not_connected and args and hasattr(args[0], 'connect'):
+                        device = args[0]
+                        # Check if device has is_connected property
+                        if hasattr(device, 'is_connected') and not device.is_connected:
+                            device_id = device.device_identifier if hasattr(device, 'device_identifier') else ""
+                            _LOGGER.info(
+                                f"{device_id} {func.__name__} attempt {attempt}/{max_attempts}: "
+                                f"Connection lost, attempting to reconnect..."
+                            )
+                            try:
+                                await device.connect()
+                                _LOGGER.info(f"{device_id} Reconnected successfully, retrying operation")
+                                # Don't sleep after successful reconnection - retry immediately
+                                attempt += 1
+                                continue
+                            except Exception as reconnect_err:
+                                _LOGGER.warning(
+                                    f"{device_id} Reconnection failed: {reconnect_err}, "
+                                    f"will retry in {current_delay}s"
+                                )
+
+                    device_id = ""
+                    if args and hasattr(args[0], 'device_identifier'):
+                        device_id = args[0].device_identifier + " "
 
                     if is_garbage_issue:
                         _LOGGER.warning(
-                            f"{func.__name__} attempt {attempt}/{max_attempts} failed "
+                            f"{device_id}{func.__name__} attempt {attempt}/{max_attempts} failed "
                             f"due to garbage bytes, retrying in {current_delay}s: {e}"
                         )
                     else:
                         _LOGGER.warning(
-                            f"{func.__name__} attempt {attempt}/{max_attempts} failed, "
+                            f"{device_id}{func.__name__} attempt {attempt}/{max_attempts} failed, "
                             f"retrying in {current_delay}s: {e}"
                         )
 

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

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

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

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