puda-drivers 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

puda_drivers/core/serialcontroller.py

@@ -3,12 +3,11 @@ Generic Serial Controller for communicating with devices over serial ports.
 """
 
 import serial
-import sys
 import time
 import serial.tools.list_ports
 import logging
 from typing import Optional, List, Tuple
-from abc import ABC, abstractmethod
+from abc import ABC
 
 logger = logging.getLogger(__name__)
 
@@ -58,23 +57,6 @@ class SerialController(ABC):
 
         self.connect()
 
-    @staticmethod
-    def list_ports(filter_desc: Optional[str] = None) -> List[Tuple[str, str, str]]:
-        """
-        Lists available serial ports on the system.
-
-        .. deprecated:: 0.0.1
-           Use the module-level function :func:`list_serial_ports` instead.
-           This method is kept for backward compatibility.
-
-        Args:
-            filter_desc: Optional string to filter ports by description (case-insensitive).
-
-        Returns:
-            List of tuples, where each tuple contains (port_name, description, hwid).
-        """
-        return list_serial_ports(filter_desc)
-
     def connect(self) -> None:
         """
         Establishes the serial connection to the port.
@@ -89,7 +71,9 @@ class SerialController(ABC):
 
         try:
             self._logger.info(
-                f"Attempting connection to {self.port_name} at {self.baudrate} baud."
+                "Attempting connection to %s at %s baud.",
+                self.port_name,
+                self.baudrate,
             )
             self._serial = serial.Serial(
                 port=self.port_name,
@@ -97,10 +81,10 @@ class SerialController(ABC):
                 timeout=self.timeout,
             )
             self._serial.flush()
-            self._logger.info(f"Successfully connected to {self.port_name}.")
+            self._logger.info("Successfully connected to %s.", self.port_name)
         except serial.SerialException as e:
             self._serial = None
-            self._logger.error(f"Error connecting to port {self.port_name}: {e}")
+            self._logger.error("Error connecting to port %s: %s", self.port_name, e)
             raise serial.SerialException(
                 f"Error connecting to port {self.port_name}: {e}"
             )
@@ -113,7 +97,7 @@ class SerialController(ABC):
             port_name = self._serial.port
             self._serial.close()
             self._serial = None
-            self._logger.info(f"Serial connection to {port_name} closed.")
+            self._logger.info("Serial connection to %s closed.", port_name)
         else:
             self._logger.warning(
                 "Serial port already disconnected or was never connected."
@@ -131,29 +115,31 @@ class SerialController(ABC):
         """
         if not self.is_connected or not self._serial:
             self._logger.error(
-                f"Attempt to send command '{command}' failed: Device not connected."
+                "Attempt to send command '%s' failed: Device not connected.",
+                command,
             )
             # Retain raising an error for being disconnected, as that's a connection state issue
             raise serial.SerialException("Device not connected. Call connect() first.")
 
-        command_bytes = bytes(command, "utf-8")
-        self._logger.info(f"-> Sending: {repr(command)}")
+        self._logger.info("-> Sending: %r", command)
 
         # Send the command
         try:
             self._serial.reset_input_buffer()  # clear input buffer
             self._serial.reset_output_buffer()  # clear output buffer
-            self._serial.write(command_bytes)
+            self._serial.write(bytes(command, "utf-8"))
             self._serial.flush()
 
         except serial.SerialTimeoutException as e:
             # Log the timeout error and return None as requested (no re-raise)
-            self._logger.error(f"Timeout on command '{command}'. Error: {e}")
+            self._logger.error("Timeout on command '%s'. Error: %s", command, e)
             return None
 
         except serial.SerialException as e:
             self._logger.error(
-                f"Serial error writing or reading command '{command}'. Error: {e}"
+                "Serial error writing or reading command '%s'. Error: %s",
+                command,
+                e,
             )
             return None
 
@@ -173,22 +159,51 @@ class SerialController(ABC):
                 # Read all available bytes
                 response += self._serial.read(self._serial.in_waiting)
 
-                # 5. Check if the 'ok' response is in the accumulated data
-                if b"ok" in response:
-                    self._logger.debug(f"<- Received response: {response!r}")
-                    return response.decode("utf-8", errors="ignore").strip()
-                if b"err" in response:
-                    self._logger.error(f"<- Received error: {response!r}")
-                    return response.decode("utf-8", errors="ignore").strip()
+                # Check for expected response markers for early return
+                if b"ok" in response or b"err" in response:
+                    break
             else:
                 time.sleep(0.1)
 
+        # Timeout reached - check what we got
         if not response:
-            self._logger.warning("<- Received no data (empty response).")
-            self._logger.error(f"No response within {self.timeout} seconds.")
-            sys.exit(124)  # Exit code for timeout
-
-        self._logger.info(
-            f"<- Received: {response.decode('utf-8', errors='ignore').strip()!r}"
-        )
-        return response.decode("utf-8", errors="ignore").strip()
+            self._logger.error("No response within %s seconds.", self.timeout)
+            raise serial.SerialTimeoutException(
+                f"No response received within {self.timeout} seconds."
+            )
+
+        # Decode once and check the decoded string
+        decoded_response = response.decode("utf-8", errors="ignore").strip()
+        
+        if "ok" in decoded_response.lower():
+            self._logger.debug("<- Received response: %r", decoded_response)
+        elif "err" in decoded_response.lower():
+            self._logger.error("<- Received error: %r", decoded_response)
+        else:
+            self._logger.warning(
+                "<- Received unexpected response (no 'ok' or 'err'): %r", decoded_response
+            )
+        
+        return decoded_response
+
+    def execute(self, command: str) -> str:
+        """
+        Send a command and read the response atomically.
+        
+        This method combines sending a command and reading its response into a
+        single atomic operation, ensuring the response corresponds to the command
+        that was just sent. This is the preferred method for commands that
+        require a response.
+        
+        Args:
+            command: Command string to send (should include protocol terminator if needed)
+            
+        Returns:
+            Response string from the device
+            
+        Raises:
+            serial.SerialException: If device is not connected or communication fails
+            serial.SerialTimeoutException: If no response is received within timeout
+        """
+        self._send_command(command)
+        return self._read_response()