python-jebao 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

jebao/__init__.py

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

jebao/device.py

@@ -4,7 +4,7 @@ import logging
 from typing import Optional
 
 from .const import DEFAULT_TIMEOUT, DeviceState
-from .exceptions import JebaoConnectionError
+from .exceptions import JebaoCommandError
 from .protocol import JebaoProtocol
 from .retry import async_retry
 
@@ -29,7 +29,6 @@ class JebaoDevice:
             device_id: Device ID (from discovery)
             model: Device model
         """
-        self.host = host
         self.port = port
         self.device_id = device_id
         self.model = model
@@ -39,6 +38,15 @@ class JebaoDevice:
         self._speed: Optional[int] = None
         self._last_update: Optional[float] = None
 
+    @property
+    def host(self) -> str:
+        """Device IP address. Setting it takes effect on the next operation."""
+        return self._protocol.host
+
+    @host.setter
+    def host(self, value: str) -> None:
+        self._protocol.host = value
+
     @property
     def device_identifier(self) -> str:
         """Get device identifier for logging."""
@@ -87,25 +95,23 @@ class JebaoDevice:
         return self._state in (DeviceState.ON, DeviceState.OFF)
 
     async def connect(self, timeout: float = DEFAULT_TIMEOUT) -> None:
-        """Connect to device.
+        """Verify the device is reachable and fetch initial status.
 
-        Args:
-            timeout: Connection timeout
+        No connection is held open afterwards; every operation opens its own
+        short-lived session (the pump drops idle sessions after ~10 s).
 
         Raises:
             JebaoConnectionError: Connection failed
             JebaoAuthenticationError: Authentication failed
+            JebaoTimeoutError: Operation timed out
         """
-        await self._protocol.connect(timeout)
-        _LOGGER.info("%s Connected (%s)", self.device_identifier, self.model or "Unknown")
-
-        # Get initial status
-        await self.update()
+        await self.update(timeout)
+        _LOGGER.debug("%s Connected (%s)", self.device_identifier, self.model or "Unknown")
 
     async def disconnect(self) -> None:
         """Disconnect from device."""
         await self._protocol.disconnect()
-        _LOGGER.info("%s Disconnected", self.device_identifier)
+        _LOGGER.debug("%s Disconnected", self.device_identifier)
 
     @async_retry(max_attempts=3, delay=0.5)
     async def update(self, timeout: float = DEFAULT_TIMEOUT) -> None:
@@ -120,24 +126,27 @@ class JebaoDevice:
         """
         import time
 
-        if not self.is_connected:
-            raise JebaoConnectionError("Not connected")
-
         response = await self._protocol.request_status(timeout)
         status = self._protocol.parse_status(response)
-
-        if status:
-            self._state = DeviceState(status["state"])
-            self._speed = status["speed"]
-            self._last_update = time.time()
-            _LOGGER.debug(
-                "%s Status updated: state=%s, speed=%d%%",
-                self.device_identifier,
-                self._state.name,
-                self._speed,
-            )
-        else:
-            _LOGGER.warning("%s Failed to parse status response", self.device_identifier)
+        if not status:
+            raise JebaoCommandError(f"Unparseable status response: {response[:24].hex()}")
+
+        try:
+            state = DeviceState(status["state"])
+        except ValueError as err:
+            raise JebaoCommandError(
+                f"Unknown device state 0x{status['state']:02x}"
+            ) from err
+
+        self._state = state
+        self._speed = status["speed"]
+        self._last_update = time.time()
+        _LOGGER.debug(
+            "%s Status updated: state=%s, speed=%d%%",
+            self.device_identifier,
+            self._state.name,
+            self._speed,
+        )
 
     async def __aenter__(self):
         """Async context manager entry."""

jebao/discovery.py

@@ -20,6 +20,20 @@ from .exceptions import JebaoError
 
 _LOGGER = logging.getLogger(__name__)
 
+DISCOVERY_SEND_COUNT = 3
+DISCOVERY_RESEND_INTERVAL = 0.7  # seconds
+
+# Every scan binds UDP 37479 (the port the official app uses). Two concurrent
+# scans in one process would split the replies between sockets, so serialise.
+_DISCOVERY_LOCK: Optional[asyncio.Lock] = None
+
+
+def _discovery_lock() -> asyncio.Lock:
+    global _DISCOVERY_LOCK
+    if _DISCOVERY_LOCK is None:
+        _DISCOVERY_LOCK = asyncio.Lock()
+    return _DISCOVERY_LOCK
+
 
 @dataclass
 class DiscoveredDevice:
@@ -136,6 +150,7 @@ class JebaoDiscovery:
             List of discovered devices on this interface
         """
         devices: List[DiscoveredDevice] = []
+        sender: Optional[asyncio.Task] = None
 
         # Get broadcast address for interface
         broadcast_addr = self._get_broadcast_address(interface)
@@ -173,10 +188,20 @@ class JebaoDiscovery:
                 UDP_DISCOVERY_PORT,
                 local_ip or "any",
             )
-            sock.sendto(
-                self.DISCOVERY_REQUEST, (broadcast_addr, UDP_DISCOVERY_PORT)
-            )
-            _LOGGER.debug("Discovery request sent: %s", self.DISCOVERY_REQUEST.hex())
+            # UDP is lossy (and pumps are on Wi-Fi): a single broadcast was
+            # regularly missed. Re-send a few times while listening.
+            async def _send_repeatedly() -> None:
+                for _ in range(DISCOVERY_SEND_COUNT):
+                    try:
+                        sock.sendto(
+                            self.DISCOVERY_REQUEST, (broadcast_addr, UDP_DISCOVERY_PORT)
+                        )
+                        _LOGGER.debug("Discovery request sent: %s", self.DISCOVERY_REQUEST.hex())
+                    except OSError as err:
+                        _LOGGER.debug("Discovery send failed on %s: %s", interface, err)
+                    await asyncio.sleep(min(DISCOVERY_RESEND_INTERVAL, timeout / DISCOVERY_SEND_COUNT))
+
+            sender = asyncio.create_task(_send_repeatedly())
 
             # Listen for responses
             end_time = asyncio.get_event_loop().time() + timeout
@@ -224,6 +249,12 @@ class JebaoDiscovery:
         except Exception as err:
             _LOGGER.error("Discovery failed on %s: %s", interface, err)
         finally:
+            if sender is not None:
+                sender.cancel()
+                try:
+                    await sender
+                except asyncio.CancelledError:
+                    pass
             if sock:
                 sock.close()
 
@@ -395,5 +426,6 @@ async def discover_devices(
         >>> devices = await discover_devices()
         >>> mdp20000_devices = [d for d in devices if d.is_mdp20000]
     """
-    discovery = JebaoDiscovery()
-    return await discovery.discover(timeout=timeout, interfaces=interfaces)
+    async with _discovery_lock():
+        discovery = JebaoDiscovery()
+        return await discovery.discover(timeout=timeout, interfaces=interfaces)

jebao/mdp20000.py

@@ -14,7 +14,6 @@ from .const import (
 )
 from .device import JebaoDevice
 from .exceptions import JebaoCommandError, JebaoInvalidStateError
-from .retry import async_retry
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -40,7 +39,6 @@ class MDP20000Device(JebaoDevice):
         super().__init__(host, port, device_id, MODEL_MDP20000)
         self._feed_duration: int = 1  # Last configured feed duration
 
-    @async_retry(max_attempts=3, delay=0.5)
     async def ensure_manual_mode(self, timeout: float = COMMAND_TIMEOUT) -> None:
         """Ensure device is in manual mode.
 
@@ -76,7 +74,6 @@ class MDP20000Device(JebaoDevice):
         else:
             _LOGGER.debug("Device already in manual mode")
 
-    @async_retry(max_attempts=3, delay=0.5)
     async def turn_on(self, timeout: float = COMMAND_TIMEOUT) -> None:
         """Turn pump on.
 
@@ -87,8 +84,7 @@ class MDP20000Device(JebaoDevice):
             JebaoCommandError: Command failed
 
         Note:
-            This method automatically retries up to 3 times on transient
-            failures (garbage bytes, connection issues).
+            Session setup is retried; the command itself is sent at most once.
         """
         _LOGGER.info("%s Turning on pump", self.device_identifier)
 
@@ -101,7 +97,6 @@ class MDP20000Device(JebaoDevice):
         # Note: Call update() after a delay to see new state
         # The pump needs time to process the command
 
-    @async_retry(max_attempts=3, delay=0.5)
     async def turn_off(self, timeout: float = COMMAND_TIMEOUT) -> None:
         """Turn pump off.
 
@@ -112,8 +107,7 @@ class MDP20000Device(JebaoDevice):
             JebaoCommandError: Command failed
 
         Note:
-            This method automatically retries up to 3 times on transient
-            failures (garbage bytes, connection issues).
+            Session setup is retried; the command itself is sent at most once.
         """
         _LOGGER.info("%s Turning off pump", self.device_identifier)
 
@@ -125,7 +119,6 @@ class MDP20000Device(JebaoDevice):
 
         # Note: Call update() after a delay to see new state
 
-    @async_retry(max_attempts=3, delay=0.5)
     async def set_speed(
         self, percentage: int, timeout: float = COMMAND_TIMEOUT
     ) -> None:
@@ -140,8 +133,7 @@ class MDP20000Device(JebaoDevice):
             JebaoCommandError: Command failed
 
         Note:
-            This method automatically retries up to 3 times on transient
-            failures (garbage bytes, connection issues).
+            Session setup is retried; the command itself is sent at most once.
         """
         if not MIN_SPEED <= percentage <= MAX_SPEED:
             raise ValueError(
@@ -194,7 +186,6 @@ class MDP20000Device(JebaoDevice):
 
         self._feed_duration = minutes
 
-    @async_retry(max_attempts=3, delay=1.0, backoff=1.5)
     async def start_feed(
         self, minutes: Optional[int] = None, timeout: float = COMMAND_TIMEOUT
     ) -> None:
@@ -213,9 +204,7 @@ class MDP20000Device(JebaoDevice):
             JebaoInvalidStateError: Device not in valid state for feed mode
 
         Note:
-            This method automatically retries up to 3 times on transient
-            failures (garbage bytes, connection issues) with longer delays
-            due to increased garbage accumulation risk.
+            Session setup is retried; the command itself is sent at most once.
         """
         # Verify device is in manual mode
         await self.update()
@@ -245,7 +234,6 @@ class MDP20000Device(JebaoDevice):
         # Update status
         await self.update()
 
-    @async_retry(max_attempts=3, delay=1.0, backoff=1.5)
     async def cancel_feed(
         self, resume_speed: Optional[int] = None, timeout: float = COMMAND_TIMEOUT
     ) -> None:
@@ -261,9 +249,7 @@ class MDP20000Device(JebaoDevice):
             JebaoInvalidStateError: Device not in feed mode
 
         Note:
-            This method automatically retries up to 3 times on transient
-            failures (garbage bytes, connection issues) with longer delays
-            due to increased garbage accumulation risk.
+            Session setup is retried; the command itself is sent at most once.
         """
         # Verify device is in feed mode
         await self.update()