sleap/gui/widgets/monitor.py (2)

Line range hint 780-830: Refactor _setup_zmq for better separation of concerns.

The method handles multiple responsibilities: context management, port selection, socket setup, and timer initialization. Consider breaking it down into smaller, focused methods.

Suggested refactoring:

def _setup_zmq(self, zmq_context: Optional[zmq.Context] = None):
    """Connect to ZMQ ports that listen to commands and updates."""
    self._initialize_context(zmq_context)
    self._setup_subscriber()
    if self.show_controller:
        self._setup_controller()
    self._setup_message_timer()

def _initialize_context(self, zmq_context: Optional[zmq.Context] = None):
    """Initialize ZMQ context."""
    self.ctx_given = zmq_context is not None
    self.ctx = zmq.Context() if zmq_context is None else zmq_context

def _setup_subscriber(self):
    """Set up the subscriber socket."""
    self.sub = self.ctx.socket(zmq.SUB)
    self.sub.subscribe("")
    publish_port = self._find_free_port(self.zmq_ports["publish_port"])
    self.zmq_ports["publish_port"] = publish_port
    publish_address = f"tcp://127.0.0.1:{publish_port}"
    self._bind_with_retry(self.sub, publish_address)

def _setup_controller(self):
    """Set up the controller socket."""
    self.zmq_ctrl = self.ctx.socket(zmq.PUB)
    controller_port = self._find_free_port(self.zmq_ports["controller_port"])
    self.zmq_ports["controller_port"] = controller_port
    controller_address = f"tcp://127.0.0.1:{controller_port}"
    self.zmq_ctrl.bind(controller_address)

def _setup_message_timer(self):
    """Set up the message polling timer."""
    self.timer = QtCore.QTimer()
    self.timer.timeout.connect(self._check_messages)
    self.timer.start(self.message_poll_time_ms)

---

Line range hint 1012-1031: Enhance socket cleanup robustness.

Consider implementing the context manager protocol and adding error handling for socket cleanup operations.

Suggested implementation:

+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._unbind()
+
     def _unbind(self):
         """Disconnect from all ZMQ sockets."""
         if self.sub is not None:
-            self.sub.unbind(self.sub.LAST_ENDPOINT)
-            self.sub.close()
+            try:
+                if self.sub.LAST_ENDPOINT:
+                    self.sub.unbind(self.sub.LAST_ENDPOINT)
+                self.sub.close()
+            except zmq.ZMQError as e:
+                logger.warning(f"Error during subscriber socket cleanup: {e}")
             self.sub = None

         if self.zmq_ctrl is not None:
-            url = self.zmq_ctrl.LAST_ENDPOINT
-            self.zmq_ctrl.unbind(url)
-            self.zmq_ctrl.close()
+            try:
+                if self.zmq_ctrl.LAST_ENDPOINT:
+                    self.zmq_ctrl.unbind(self.zmq_ctrl.LAST_ENDPOINT)
+                self.zmq_ctrl.close()
+            except zmq.ZMQError as e:
+                logger.warning(f"Error during controller socket cleanup: {e}")
             self.zmq_ctrl = None

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

sleap/gui/utils.py (2)

33-42: Add return type hint and improve documentation

The function's type hints and documentation could be enhanced:

1. Add return type hint
2. Document possible exceptions
3. Add example usage

-def find_free_port(port: int, zmq_context: zmq.Context):
+def find_free_port(port: int, zmq_context: zmq.Context) -> int:
     """Find free port to bind to.
 
     Args:
         port: The port to start searching from.
         zmq_context: The ZMQ context to use.
 
     Returns:
         The free port.
+
+    Raises:
+        RuntimeError: If no free port is found after max_attempts.
+        ValueError: If port number is invalid.
+
+    Example:
+        >>> ctx = zmq.Context()
+        >>> free_port = find_free_port(5555, ctx)
     """

---

33-55: Consider implementing port reservation mechanism

The current implementation has a potential race condition: another process could take the port between the time we check it's free and when it's actually used. Consider these architectural improvements:

1. Implement a port reservation system using file locks
2. Keep the socket bound until actual use
3. Use a dedicated port range for the application

This would provide more reliable port allocation in multi-process scenarios.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

sleap/gui/widgets/monitor.py (1)

Line range hint 447-448: Fix inconsistency in log scale minimum value.

The comment mentions setting minimum to 0.001 but the code uses 1e-8. This could lead to numerical stability issues with very small values.

-            y_min = max(y_min, 1e-8)
+            y_min = max(y_min, 0.001)  # Minimum value for log scale to maintain numerical stability

sleap/gui/widgets/monitor.py (1)

Line range hint 1052-1059: Add missing type hints and improve documentation.

Consider adding return type hints and improving parameter documentation for better code maintainability.

-    def _toggle_ignore_outliers(self):
+    def _toggle_ignore_outliers(self) -> None:
         """Toggles whether to ignore outliers in chart scaling."""
 
-    def _toggle_log_scale(self):
+    def _toggle_log_scale(self) -> None:
         """Toggle whether to use log-scaled y-axis."""

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro