chore: forgot copyright

ref: N25B-397

src/robot_interface/__init__.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""

src/robot_interface/core/__init__.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""

src/robot_interface/core/config.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from __future__ import unicode_literals
 
 from robot_interface.utils.get_config import get_config
@@ -24,6 +17,10 @@ class AgentSettings(object):
     :vartype video_sender_port: int
     :ivar audio_sender_port: Port used for sending audio data, defaults to 5558.
     :vartype audio_sender_port: int
+    :ivar face_detection_port: Port used for sending face detection events, defaults to 5559.
+    :vartype face_detection_port: int
+    :ivar face_detection_interval: Time between face detection events, defaults to 1000 ms.
+    :vartype face_detection_interval: int
     """
     def __init__(
         self,
@@ -32,12 +29,16 @@ class AgentSettings(object):
         main_receiver_port=None,
         video_sender_port=None,
         audio_sender_port=None,
+        face_detection_port=None,
+        face_detection_interval=None,
     ):
         self.control_backend_host = get_config(control_backend_host, "AGENT__CONTROL_BACKEND_HOST", "localhost")
         self.actuation_receiver_port = get_config(actuation_receiver_port, "AGENT__ACTUATION_RECEIVER_PORT", 5557, int)
         self.main_receiver_port = get_config(main_receiver_port, "AGENT__MAIN_RECEIVER_PORT", 5555, int)
         self.video_sender_port = get_config(video_sender_port, "AGENT__VIDEO_SENDER_PORT", 5556, int)
         self.audio_sender_port = get_config(audio_sender_port, "AGENT__AUDIO_SENDER_PORT", 5558, int)
+        self.face_detection_port = get_config(face_detection_port, "AGENT__FACE_DETECTION_PORT", 5559, int)
+        self.face_detection_interval = get_config(face_detection_interval, "AGENT__FACE_DETECTION_INTERVAL", 1000, int)
 
 
 class VideoConfig(object):

src/robot_interface/endpoints/__init__.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""

src/robot_interface/endpoints/actuation_receiver.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from __future__ import unicode_literals  # So that we can log texts with Unicode characters
 import logging
 from threading import Thread

src/robot_interface/endpoints/audio_sender.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from __future__ import unicode_literals  # So that `logging` can use Unicode characters in names
 import threading
 import logging
@@ -84,23 +77,16 @@ class AudioSender(SocketBase):
         chunk = audio_settings.chunk_size # 320 at 16000 Hz is 20ms, 512 is required for Silero-VAD
 
         # Docs say this only raises an error if neither `input` nor `output` is True
-        def open_stream():
-            return self.audio.open(
-                format=pyaudio.paFloat32,
-                channels=audio_settings.channels,
-                rate=audio_settings.sample_rate,
-                input=True,
-                input_device_index=self.microphone["index"],
-                frames_per_buffer=chunk,
-            )
-        
-        stream = None
+        stream = self.audio.open(
+            format=pyaudio.paFloat32,
+            channels=audio_settings.channels,
+            rate=audio_settings.sample_rate,
+            input=True,
+            input_device_index=self.microphone["index"],
+            frames_per_buffer=chunk,
+        )
 
         try:
-            # Test in case exit_event was set while waiting
-            if not state.exit_event.is_set():
-                stream = open_stream()
-            
             while not state.exit_event.is_set():
                 data = stream.read(chunk)
                 if (state.is_speaking): continue  # Do not send audio while the robot is speaking
@@ -108,9 +94,5 @@ class AudioSender(SocketBase):
         except IOError as e:
             logger.error("Stopped listening: failed to get audio from microphone.", exc_info=e)
         finally:
-            if stream:
-                try:
-                    stream.stop_stream()
-                    stream.close()
-                except IOError:
-                    pass # Ignore errors on closing
+            stream.stop_stream()
+            stream.close()

src/robot_interface/endpoints/face_detector.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+from __future__ import unicode_literals
+
+import json
+import logging
+import threading
+import time
+import zmq
+
+from robot_interface.endpoints.socket_base import SocketBase
+from robot_interface.state import state
+from robot_interface.core.config import settings
+
+
+class FaceDetectionSender(SocketBase):
+    """
+    Face detection endpoint.
+
+    Subscribes to and polls ALMemory["FaceDetected"], sends events to CB.
+    """
+
+    def __init__(self, zmq_context, port=settings.agent_settings.face_detection_port):
+        super(FaceDetectionSender, self).__init__("face")
+
+        self.create_socket(zmq_context, zmq.PUB, port)
+
+        self._face_service = None
+        self._memory_service = None
+
+        self._face_thread = None
+
+    def start_face_detection(self):
+        if not state.qi_session:
+            logging.warning("No Qi session available. Face detection not started.")
+            return
+
+        self._face_service = state.qi_session.service("ALFaceDetection")
+        self._memory_service = state.qi_session.service("ALMemory")
+
+        self._face_service.setTrackingEnabled(False)
+        self._face_service.setRecognitionEnabled(False)
+
+        self._face_service.subscribe(
+            "FaceDetectionSender",
+            settings.agent_settings.face_detection_interval,
+            0.0,
+        )
+
+        self._face_thread = threading.Thread(target=self._face_loop)
+        self._face_thread.start()
+
+        logging.info("Face detection started.")
+
+    def _face_loop(self):
+        """
+        Continuously send face detected to the CB, at the interval set in the
+        ``start_face_detection`` method.
+        """
+        while not state.exit_event.is_set():
+            try:
+                value = self._memory_service.getData("FaceDetected", 0)
+
+                face_present = (
+                    value
+                    and len(value) > 1
+                    and value[1]
+                    and value[1][0]
+                    and len(value[1][0]) > 0
+                )
+
+                self.socket.send(json.dumps({"face_detected": face_present}).encode("utf-8"))
+            except Exception:
+                logging.exception("Error reading FaceDetected")
+
+            time.sleep(settings.agent_settings.face_detection_interval / 1000.0)
+
+    def stop_face_detection(self):
+        try:
+            if self._face_service:
+                self._face_service.unsubscribe("FaceDetectionSender")
+                self._face_service.setTrackingEnabled(False)
+            logging.info("Face detection stopped.")
+        except Exception:
+            logging.warning("Error during face detection cleanup.")
+
+    def close(self):
+        super(FaceDetectionSender, self).close()
+        self.stop_face_detection()

src/robot_interface/endpoints/gesture_settings.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 class GestureTags:
     tags = ["above", "affirmative", "afford", "agitated", "all", "allright", "alright", "any", 
             "assuage", "assuage", "attemper", "back", "bashful", "beg", "beseech", "blank", 

src/robot_interface/endpoints/main_receiver.py

@@ -1,16 +1,10 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import zmq
 
 from robot_interface.endpoints.receiver_base import ReceiverBase
 from robot_interface.state import state
 
 from robot_interface.core.config import settings
+from robot_interface.endpoints.face_detector import FaceDetectionSender
 
 
 class MainReceiver(ReceiverBase):
@@ -44,6 +38,7 @@ class MainReceiver(ReceiverBase):
         """
         return {"endpoint": "ping", "data": message.get("data")}
 
+
     @staticmethod
     def _handle_port_negotiation(message):
         """
@@ -78,30 +73,6 @@ class MainReceiver(ReceiverBase):
             return MainReceiver._handle_port_negotiation(message)
 
         return {"endpoint": "negotiate/error", "data": "The requested endpoint is not implemented."}
-    
-    @staticmethod
-    def _handle_pause(message):
-        """
-        Handle a pause request. Pauses or resumes the video and audio streams.
-
-        :param message: The pause request message.
-        :type message: dict
-
-        :return: A response dictionary indicating success.
-        :rtype: dict[str, str]
-        """
-        if message.get("data"):
-            if state.active_event.is_set():
-                state.active_event.clear()
-                return {"endpoint": "pause", "data": "Streams paused."}
-            else:
-                return {"endpoint": "pause", "data": "Streams are already paused."}
-        else:
-            if not state.active_event.is_set():
-                state.active_event.set()
-                return {"endpoint": "pause", "data": "Streams resumed."}
-            else:
-                return {"endpoint": "pause", "data": "Streams are already running."}
 
     def handle_message(self, message):
         """
@@ -119,7 +90,5 @@ class MainReceiver(ReceiverBase):
             return self._handle_ping(message)
         elif message["endpoint"].startswith("negotiate"):
             return self._handle_negotiation(message)
-        elif message["endpoint"] == "pause":
-            return self._handle_pause(message)
 
         return {"endpoint": "error", "data": "The requested endpoint is not supported."}

src/robot_interface/endpoints/receiver_base.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from abc import ABCMeta, abstractmethod
 
 from robot_interface.endpoints.socket_base import SocketBase

src/robot_interface/endpoints/socket_base.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from abc import ABCMeta
 
 import zmq

src/robot_interface/endpoints/video_sender.py

@@ -1,16 +1,6 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-import struct
 import zmq
 import threading
 import logging
-import numpy as np
-
-import cv2
 
 from robot_interface.endpoints.socket_base import SocketBase
 from robot_interface.state import state
@@ -29,7 +19,7 @@ class VideoSender(SocketBase):
     """
     def __init__(self, zmq_context, port=settings.agent_settings.video_sender_port):
         super(VideoSender, self).__init__("video")
-        self.create_socket(zmq_context, zmq.PUB, port, [(zmq.SNDHWM,3)])
+        self.create_socket(zmq_context, zmq.PUB, port, [(zmq.CONFLATE,1)])
     
     def start_video_rcv(self):
         """
@@ -39,9 +29,6 @@ class VideoSender(SocketBase):
         """
         if not state.qi_session:
             logging.info("No Qi session available. Not starting video loop.")
-            logging.info("Starting test video stream from local webcam.")
-            thread = threading.Thread(target=self.test_video_stream)
-            thread.start()
             return
 
         video = state.qi_session.service("ALVideoDevice")
@@ -55,40 +42,9 @@ class VideoSender(SocketBase):
         thread = threading.Thread(target=self.video_rcv_loop, args=(video, vid_stream_name))
         thread.start()
 
-    def test_video_stream(self):
-        """
-        Test function to send video from a local webcam instead of the robot.
-        """
-        cap = cv2.VideoCapture(0)
-        if not cap.isOpened():
-            logging.error("Could not open webcam for video stream test.")
-            return
-
-        while not state.exit_event.is_set():
-
-            ret, frame = cap.read()
-            if not ret:
-                logging.warning("Failed to read frame from webcam.")
-                continue
-
-            if cv2.waitKey(1) & 0xFF == ord('q'): # << Add this: Updates the window
-                break
-            
-            height, width, channels = frame.shape
-            
-            pixel_data = frame.tobytes()
-
-            width_bytes = struct.pack('<I', width)
-            height_bytes = struct.pack('<I', height)
-
-            self.socket.send_multipart([width_bytes, height_bytes, pixel_data])
-
-        cap.release()
-
     def video_rcv_loop(self, vid_service, vid_stream_name):
         """
         The main loop of retrieving video images from the robot.
-        Sends the image data over the ZMQ socket in 3 parts: image width, image height and raw image bytes.
 
         :param vid_service: The video service object that the active Qi session is connected to. 
         :type vid_service: Object (Qi service object)
@@ -96,23 +52,10 @@ class VideoSender(SocketBase):
         :param vid_stream_name: The name of a camera subscription on the video service object vid_service
         :type vid_stream_name: str
         """
-        try:
-            while not state.exit_event.is_set():
-                try:
-                    img = vid_service.getImageRemote(vid_stream_name)
-                    if img is not None:
-                        image_bytes = img[6]
-                        width = img[0]
-                        height = img[1]
-
-                        width_bytes = struct.pack('<I', width)
-                        height_bytes = struct.pack('<I', height)
-
-                        self.socket.send_multipart([width_bytes, height_bytes, image_bytes])
-                except:
-                    logging.warn("Failed to retrieve video image from robot.")
-        except KeyboardInterrupt:
-            logging.info("Video receiving loop interrupted by user.")
-        finally:
-            vid_service.unsubscribe(vid_stream_name)
-            logging.info("Unsubscribed from video stream.")
+        while not state.exit_event.is_set():
+            try:
+                img = vid_service.getImageRemote(vid_stream_name)
+                #Possibly limit images sent if queuing issues arise
+                self.socket.send(img[settings.video_config.image_buffer])
+            except:
+                logging.warn("Failed to retrieve video image from robot.")

src/robot_interface/main.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import logging
 
 from robot_interface.endpoints.audio_sender import AudioSender
@@ -19,6 +12,8 @@ from robot_interface.endpoints.video_sender import VideoSender
 from robot_interface.state import state
 from robot_interface.core.config import settings
 from robot_interface.utils.timeblock import TimeBlock
+from robot_interface.endpoints.face_detector import FaceDetectionSender
+
 
 
 def main_loop(context):
@@ -42,6 +37,12 @@ def main_loop(context):
     video_sender.start_video_rcv()
     audio_sender.start()
 
+    # --- Face detection sender ---
+    face_sender = FaceDetectionSender(context)
+    state.sockets.append(face_sender)
+    face_sender.start_face_detection()
+
+
     # Sockets that can run on the main thread. These sockets' endpoints should not block for long (say 50 ms at most).
     receivers = [main_receiver, actuation_receiver]
 
@@ -91,7 +92,6 @@ def main():
     context = zmq.Context()
 
     state.initialize()
-    state.active_event.set()
 
     try:
         main_loop(context)

src/robot_interface/state.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import logging
 import signal
 import threading
@@ -56,8 +49,6 @@ class State(object):
         signal.signal(signal.SIGINT, handle_exit)
         signal.signal(signal.SIGTERM, handle_exit)
 
-        self.active_event = threading.Event()
-
         self.qi_session = get_qi_session()
 
         self.is_initialized = True

src/robot_interface/utils/__init__.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""

src/robot_interface/utils/get_config.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import os
 from dotenv import load_dotenv
 

src/robot_interface/utils/microphone.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from __future__ import unicode_literals  # So that `print` can print Unicode characters in names
 import logging
 import sys

src/robot_interface/utils/qi_utils.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import logging
 import sys
 

src/robot_interface/utils/timeblock.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import time
 
 

test/common/__init__.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""

test/common/microphone_utils.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from __future__ import unicode_literals  # So that we can format strings with Unicode characters
 import random
 import sys

test/conftest.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from mock import patch, MagicMock
 
 import pytest

test/integration/__init__.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""

test/integration/test_config.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from mock import patch, mock
 
 from robot_interface.core.config import Settings

test/integration/test_microphone_utils.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import pyaudio
 
 import pytest

test/unit/__init__.py

@@ -1,6 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""

test/unit/test_actuation_receiver.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import sys
 
 import mock

test/unit/test_audio_sender.py

@@ -1,10 +1,4 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
+# coding=utf-8
 import os
 
 import mock
@@ -39,6 +33,7 @@ def test_no_microphone(zmq_context, mocker):
 
     sender.start()
     assert sender.thread is None
+    mock_info_logger.assert_called()
 
     sender.wait_until_done()  # Should return early because we didn't start a thread
 
@@ -78,7 +73,7 @@ def test_sending_audio(mocker):
     mock_choose_mic.return_value = {"name": u"Some mic", "index": 0L}
 
     mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.exit_event.is_set.side_effect = [False, False, True]
+    mock_state.exit_event.is_set.side_effect = [False, True]
 
     mock_zmq_context = mock.Mock()
     send_socket = mock.Mock()
@@ -98,217 +93,6 @@ def test_sending_audio(mocker):
 
     send_socket.assert_called()
 
-# SENDING PAUSE RESUME?
-
-def test_stream_initial_wait_exit(mocker):
-    mock_choose_mic = mocker.patch("robot_interface.endpoints.audio_sender.choose_mic")
-    mock_choose_mic.return_value = {"name": u"Some mic", "index": 0L}
-
-    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
-    mock_pyaudio_instance = mock_pyaudio_cls.return_value
-
-    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.exit_event.is_set.return_value = True
-    mock_state.active_event.is_set.return_value = False
-    
-    mock_zmq_context = mock.Mock()
-
-    sender = AudioSender(mock_zmq_context)
-    sender._stream()
-
-    mock_pyaudio_instance.open.assert_not_called()
-
-def test_stream_pause_and_resume(mocker):
-    mock_stream = mock.Mock()
-    mock_stream.read.return_value = b"data"
-
-    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
-    mock_pyaudio_instance = mock_pyaudio_cls.return_value
-    mock_pyaudio_instance.open.return_value = mock_stream
-
-    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.active_event.is_set.return_value = False
-
-    mock_state.exit_event.is_set.side_effect = [False, False, False, True]
-
-    mock_zmq_context = mock.Mock()
-    sender = AudioSender(mock_zmq_context)
-    sender.socket = mock.Mock()
-
-    sender._stream()
-
-    assert mock_pyaudio_instance.open.call_count == 2
-
-    assert mock_stream.close.call_count == 2
-    assert mock_stream.stop_stream.call_count == 2
-
-    assert mock_state.active_event.wait.called
-
-def test_stream_exit_during_pause(mocker):
-    mock_stream = mock.Mock()
-    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
-    mock_pyaudio_instance = mock_pyaudio_cls.return_value
-    mock_pyaudio_instance.open.return_value = mock_stream
-
-    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.active_event.is_set.return_value = False
-
-    mock_state.exit_event.is_set.side_effect = [False, False, True]
-
-    mock_zmq_context = mock.Mock()
-    sender = AudioSender(mock_zmq_context)
-    sender._stream()
-
-    assert mock_pyaudio_instance.open.call_count == 1
-    assert mock_stream.close.call_count == 1
-
-def test_stream_read_error_recovery(mocker):
-    stream_fail = mock.Mock()
-    stream_fail.read.side_effect = IOError("Overflow")
-
-    stream_ok = mock.Mock()
-    stream_ok.read.return_value = b"data"
-
-    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
-    mock_pyaudio_instance = mock_pyaudio_cls.return_value
-    mock_pyaudio_instance.open.side_effect = [stream_fail, stream_ok]
-
-    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.active_event.is_set.return_value = True
-    mock_state.exit_event.is_set.side_effect = [False, False, False, True]
-
-    mock_zmq_context = mock.Mock()
-    sender = AudioSender(mock_zmq_context)
-    sender.socket = mock.Mock()
-    sender._stream()
-    stream_fail.close.assert_called()
-    assert mock_pyaudio_instance.open.call_count == 2
-    sender.socket.send.assert_called_with(b"data")
-
-
-def test_stream_fatal_error(mocker):
-    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
-    mock_pyaudio_instance = mock_pyaudio_cls.return_value
-    mock_pyaudio_instance.open.side_effect = IOError("Fatal error")
-
-    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.active_event.is_set.return_value = True
-    mock_state.exit_event.is_set.return_value = False
-
-    mock_zmq_context = mock.Mock()
-    sender = AudioSender(mock_zmq_context)
-    sender._stream()
-
-def test_wait_until_done(mocker):
-    mock_zmq_context = mock.Mock()
-    
-    sender = AudioSender(mock_zmq_context)
-
-    sender.wait_until_done()
-
-    mock_thread = mocker.Mock()
-    sender.thread = mock_thread
-    sender.wait_until_done()
-
-    mock_thread.join.assert_called_once()
-    assert sender.thread is None
-
-def test_stream_pause_close_error(mocker):
-    """
-    Tests that an IOError during stream closure (when pausing) is ignored,
-    covering the 'pass' statement in the pause logic.
-    """
-    mock_stream = mock.Mock()
-    mock_stream.read.return_value = b"data"
-    # Raise IOError when stopping the stream during pause
-    mock_stream.stop_stream.side_effect = IOError("Failed to stop")
-
-    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
-    mock_pyaudio_instance = mock_pyaudio_cls.return_value
-    mock_pyaudio_instance.open.return_value = mock_stream
-
-    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    
-    # 1. First False triggers the pause block
-    # 2. Second True resumes the loop
-    mock_state.active_event.is_set.side_effect = [False, True] 
-
-    mock_state.exit_event.is_set.side_effect = [False, False, False, True]
-
-    mock_zmq_context = mock.Mock()
-    sender = AudioSender(mock_zmq_context)
-    sender.socket = mock.Mock()
-
-    sender._stream()
-
-    # Verification: The error should be swallowed, and the stream should re-open
-    assert mock_stream.stop_stream.called
-    assert mock_pyaudio_instance.open.call_count == 2
-
-
-def test_stream_finally_close_error(mocker):
-    """
-    Tests that an IOError during stream closure in the finally block is ignored,
-    covering the 'pass' statement in the finally logic.
-    """
-    mock_stream = mock.Mock()
-    mock_stream.read.return_value = b"data"
-    # Raise IOError when stopping the stream at exit
-    mock_stream.stop_stream.side_effect = IOError("Cleanup failed")
-
-    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
-    mock_pyaudio_instance = mock_pyaudio_cls.return_value
-    mock_pyaudio_instance.open.return_value = mock_stream
-
-    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.active_event.is_set.return_value = True
-    mock_state.exit_event.is_set.side_effect = [False, False, True]
-
-    mock_zmq_context = mock.Mock()
-    sender = AudioSender(mock_zmq_context)
-    sender.socket = mock.Mock()
-
-    # Run
-    sender._stream()
-
-    # Assert: Should finish without raising exception despite the IOError in finally
-    assert mock_stream.stop_stream.called
-
-
-def test_stream_recovery_failure(mocker):
-    """
-    Tests the case where recovering from a read error (re-opening stream) also fails.
-    This ensures the outer try-except catches exceptions from the inner except block.
-    """
-    mock_stream_initial = mock.Mock()
-    # Trigger the read error logic
-    mock_stream_initial.read.side_effect = IOError("Read failed")
-
-    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
-    mock_pyaudio_instance = mock_pyaudio_cls.return_value
-    
-    # First open works, Second open (recovery) fails fatally
-    mock_pyaudio_instance.open.side_effect = [
-        mock_stream_initial, 
-        IOError("Recovery failed")
-    ]
-
-    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.active_event.is_set.return_value = True
-    mock_state.exit_event.is_set.return_value = False
-
-    mock_logger = mocker.patch("robot_interface.endpoints.audio_sender.logger")
-    
-    mock_zmq_context = mock.Mock()
-    sender = AudioSender(mock_zmq_context)
-    sender.socket = mock.Mock()
-
-    sender._stream()
-
-    # Assert we hit the outer error log
-    mock_logger.error.assert_called()
-
-
 
 def test_no_sending_if_speaking(mocker):
     """

test/unit/test_face_detection_sender.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+from __future__ import unicode_literals
+
+import json
+import mock
+import pytest
+
+from robot_interface.endpoints.face_detector import FaceDetectionSender
+from robot_interface.state import state
+
+
+@pytest.fixture(autouse=True)
+def initialized_state(monkeypatch):
+    """
+    Fully initialize global state so __getattribute__ allows access.
+    """
+    # Bypass the initialization guard
+    monkeypatch.setattr(state, "is_initialized", True, raising=False)
+
+    # Install a controllable exit_event
+    exit_event = mock.Mock()
+    exit_event.is_set = mock.Mock(return_value=True)
+    monkeypatch.setattr(state, "exit_event", exit_event, raising=False)
+
+    # Default qi_session is None unless overridden
+    monkeypatch.setattr(state, "qi_session", None, raising=False)
+
+    yield
+
+
+def test_start_face_detection_no_qi_session():
+    """
+    Returns early when qi_session is None.
+    """
+    sender = FaceDetectionSender(mock.Mock())
+    sender.start_face_detection()
+
+    assert sender._face_thread is None
+    assert sender._face_service is None
+    assert sender._memory_service is None
+
+
+def test_start_face_detection_happy_path(mocker):
+    """
+    Initializes services and starts background thread.
+    """
+    mock_face = mock.Mock()
+    mock_memory = mock.Mock()
+
+    mock_qi = mock.Mock()
+    mock_qi.service.side_effect = lambda name: {
+        "ALFaceDetection": mock_face,
+        "ALMemory": mock_memory,
+    }[name]
+
+    state.qi_session = mock_qi
+
+    fake_thread = mock.Mock()
+    mocker.patch("threading.Thread", return_value=fake_thread)
+
+    sender = FaceDetectionSender(mock.Mock())
+    sender.start_face_detection()
+
+    mock_face.setTrackingEnabled.assert_called_with(False)
+    mock_face.setRecognitionEnabled.assert_called_with(False)
+    mock_face.subscribe.assert_called_once()
+    fake_thread.start.assert_called_once()
+
+
+def test_face_loop_face_detected_true(mocker):
+    """
+    Sends face_detected=True when face data exists.
+    """
+    sender = FaceDetectionSender(mock.Mock())
+
+    sender._memory_service = mock.Mock()
+    sender._memory_service.getData.return_value = [0, [[1]]]
+    sender.socket = mock.Mock()
+
+    mocker.patch("time.sleep")
+    state.exit_event.is_set.side_effect = [False, True]
+
+    sender._face_loop()
+
+    sent = sender.socket.send.call_args[0][0]
+    payload = json.loads(sent.decode("utf-8"))
+
+    assert payload["face_detected"] is True
+
+
+def test_face_loop_face_detected_false(mocker):
+    """
+    Sends face_detected=False when no face data exists.
+    """
+    sender = FaceDetectionSender(mock.Mock())
+
+    sender._memory_service = mock.Mock()
+    sender._memory_service.getData.return_value = []
+    sender.socket = mock.Mock()
+
+    mocker.patch("time.sleep")
+    state.exit_event.is_set.side_effect = [False, True]
+
+    sender._face_loop()
+
+    sent = sender.socket.send.call_args[0][0]
+    payload = json.loads(sent.decode("utf-8"))
+
+    assert not payload["face_detected"]
+
+
+def test_face_loop_handles_exception(mocker):
+    """
+    Exceptions inside loop are swallowed.
+    """
+    sender = FaceDetectionSender(mock.Mock())
+
+    sender._memory_service = mock.Mock()
+    sender._memory_service.getData.side_effect = Exception("boom")
+    sender.socket = mock.Mock()
+
+    mocker.patch("time.sleep")
+    state.exit_event.is_set.side_effect = [False, True]
+
+    # Must not raise
+    sender._face_loop()
+
+
+def test_stop_face_detection_happy_path():
+    """
+    Unsubscribes and disables tracking.
+    """
+    sender = FaceDetectionSender(mock.Mock())
+
+    mock_face = mock.Mock()
+    sender._face_service = mock_face
+
+    sender.stop_face_detection()
+
+    mock_face.unsubscribe.assert_called_once()
+    mock_face.setTrackingEnabled.assert_called_with(False)
+
+
+def test_stop_face_detection_exception():
+    """
+    stop_face_detection swallows service exceptions.
+    """
+    sender = FaceDetectionSender(mock.Mock())
+
+    mock_face = mock.Mock()
+    mock_face.unsubscribe.side_effect = Exception("fail")
+    sender._face_service = mock_face
+
+    sender.stop_face_detection()
+
+
+def test_close_calls_stop_face_detection(mocker):
+    """
+    close() calls parent close and stop_face_detection().
+    """
+    sender = FaceDetectionSender(mock.Mock())
+
+    mocker.patch.object(sender, "stop_face_detection")
+    mocker.patch(
+        "robot_interface.endpoints.face_detector.SocketBase.close"
+    )
+
+    sender.close()
+
+    sender.stop_face_detection.assert_called_once()

test/unit/test_get_config.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 from robot_interface.utils.get_config import get_config
 
 

test/unit/test_main.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import pytest
 import threading
 import zmq
@@ -62,6 +55,9 @@ class DummySender:
     def start(self):
         self.called = True
 
+    def start_face_detection(self):
+        self.called = True
+
     def close(self):
         pass
 
@@ -115,11 +111,13 @@ def patched_main_components(monkeypatch, fake_sockets, fake_poll):
     fake_act = FakeReceiver(act_sock)
     video_sender = DummySender()
     audio_sender = DummySender()
+    face_sender = DummySender()
 
     monkeypatch.setattr(main_mod, "MainReceiver", lambda ctx: fake_main)
     monkeypatch.setattr(main_mod, "ActuationReceiver", lambda ctx: fake_act)
     monkeypatch.setattr(main_mod, "VideoSender", lambda ctx: video_sender)
     monkeypatch.setattr(main_mod, "AudioSender", lambda ctx: audio_sender)
+    monkeypatch.setattr(main_mod, "FaceDetectionSender", lambda ctx: face_sender)
 
     # Register sockets for the fake poller
     fake_poll.registered = {main_sock: zmq.POLLIN, act_sock: zmq.POLLIN}

test/unit/test_main_receiver.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import mock
 import pytest
 import zmq

test/unit/test_microphone_utils.py

@@ -1,10 +1,4 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
+# coding=utf-8
 import mock
 import pytest
 

test/unit/test_qi_utils.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import sys
 
 # Import module under test

test/unit/test_reciever_base.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import pytest
 from robot_interface.endpoints.receiver_base import ReceiverBase
 

test/unit/test_socket_base.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import mock
 import zmq
 from robot_interface.endpoints.socket_base import SocketBase

test/unit/test_state.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import threading
 import signal
 import pytest

test/unit/test_time_block.py

@@ -1,10 +1,3 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
-
 import time
 
 import mock

test/unit/test_video_sender.py

@@ -1,171 +1,99 @@
-# -*- coding: utf-8 -*-
-"""
-This program has been developed by students from the bachelor Computer Science at Utrecht
-University within the Software Project course.
-© Copyright Utrecht University (Department of Information and Computing Sciences)
-"""
+# coding=utf-8
 
 import mock
 import pytest
 import zmq
 
 from robot_interface.endpoints.video_sender import VideoSender
+from robot_interface.state import state
+from robot_interface.core.config import settings
+
 
 @pytest.fixture
 def zmq_context():
-    """
-    Yields a real ZMQ context for socket creation.
-    """
-    context = zmq.Context()
-    yield context
-    context.term()
+    """Provide a ZMQ context."""
+    yield zmq.Context()
 
-def test_init_defaults(zmq_context, mocker):
-    """
-    Test initialization of the VideoSender.
-    """
-    # We patch settings to ensure valid port access inside the class logic, 
-    # although the default arg is evaluated at import time.
-    mocker.patch("robot_interface.endpoints.video_sender.settings")
-    
-    mock_zmq = mock.Mock()
-    sender = VideoSender(mock_zmq)
-    
-    # Verify socket type is PUB
-    assert sender.identifier == "video"
 
-def test_start_no_qi_session(mocker):
-    """
-    Test that the loop does not start if no Qi session is available.
-    """
-    # Mock state to return None for qi_session
-    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
-    mock_state.qi_session = None
-    
-    mock_threading = mocker.patch("robot_interface.endpoints.video_sender.threading")
+def _patch_basics(mocker):
+    """Common patches: prevent real threads, port binds, and state errors."""
+    mocker.patch("robot_interface.endpoints.socket_base.zmq.Socket.bind")
+    mocker.patch("robot_interface.endpoints.video_sender.threading.Thread")
+    mocker.patch.object(state, "is_initialized", True)
 
-    mock_zmq = mock.Mock()
-    sender = VideoSender(mock_zmq)
+
+def _patch_exit_event(mocker):
+    """Make exit_event stop the loop after one iteration."""
+    fake_event = mock.Mock()
+    fake_event.is_set.side_effect = [False, True]
+    mocker.patch.object(state, "exit_event", fake_event)
+
+
+def test_no_qi_session(zmq_context, mocker):
+    """Video loop should not start without a qi_session."""
+    _patch_basics(mocker)
+    mocker.patch.object(state, "qi_session", None)
+
+    sender = VideoSender(zmq_context)
     sender.start_video_rcv()
 
-    # Assertions
-    mock_threading.Thread.assert_not_called()
+    assert not hasattr(sender, "thread")
+
+
+def test_video_streaming(zmq_context, mocker):
+    """VideoSender should send retrieved image data."""
+    _patch_basics(mocker)
+    _patch_exit_event(mocker)
+
+    # Pepper's image buffer lives at index 6
+    mocker.patch.object(settings.video_config, "image_buffer", 6)
 
-def test_start_success(mocker):
-    """
-    Test successful startup of the video receiver thread.
-    """
-    # Mock the Qi Session and Service
-    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
-    mock_session = mock.Mock()
-    mock_state.qi_session = mock_session
-    
     mock_video_service = mock.Mock()
-    mock_session.service.return_value = mock_video_service
-    mock_video_service.subscribeCamera.return_value = "test_subscriber_id"
+    mock_video_service.getImageRemote.return_value = [None]*6 + ["fake_img"]
 
-    # Mock Settings
-    mock_settings = mocker.patch("robot_interface.endpoints.video_sender.settings")
-    mock_settings.video_config.camera_index = 0
-    mock_settings.video_config.resolution = 2
-    mock_settings.video_config.color_space = 11
-    mock_settings.video_config.fps = 30
-    mock_settings.video_config.stream_name = "test_stream"
+    fake_session = mock.Mock()
+    fake_session.service.return_value = mock_video_service
+    mocker.patch.object(state, "qi_session", fake_session)
 
-    mock_threading = mocker.patch("robot_interface.endpoints.video_sender.threading")
+    mocker.patch.object(
+        fake_session.service("ALVideoDevice"),
+        "subscribeCamera",
+        return_value="stream_name"
+    )
+
+    sender = VideoSender(zmq_context)
+    send_socket = mock.Mock()
+    sender.socket.send = send_socket
 
-    # Run
-    mock_zmq = mock.Mock()  
-    sender = VideoSender(mock_zmq)
     sender.start_video_rcv()
+    sender.video_rcv_loop(mock_video_service, "stream_name")
 
-    # Assertions
-    mock_session.service.assert_called_with("ALVideoDevice")
-    mock_video_service.subscribeCamera.assert_called_with("test_stream", 0, 2, 11, 30)
-    
-    mock_threading.Thread.assert_called_once()
-    # Verify arguments passed to the thread target
-    call_args = mock_threading.Thread.call_args[1]
-    assert call_args["target"] == sender.video_rcv_loop
-    assert call_args["args"] == (mock_video_service, "test_subscriber_id")
-    
-    # Ensure thread was started
-    mock_threading.Thread.return_value.start.assert_called_once()
+    send_socket.assert_called_with("fake_img")
 
-def test_video_loop_happy_path(mocker):
-    """
-    Test the main loop: Wait -> Get Image -> Send -> Repeat/Exit.
-    """
-    # Mock settings for image buffer index
-    mock_settings = mocker.patch("robot_interface.endpoints.video_sender.settings")
-    mock_settings.video_config.image_buffer = 6 
 
-    # Mock Video Service to return a fake image structure
-    # Standard NaoQi image is a list, binary data is usually at index 6
-    fake_image_data = b"binary_jpeg_data"
-    fake_image_list = [0] * 7
-    fake_image_list[6] = fake_image_data
-    
-    mock_service = mock.Mock()
-    mock_service.getImageRemote.return_value = fake_image_list
+def test_video_receive_error(zmq_context, mocker):
+    """Errors retrieving images should not call send()."""
+    _patch_basics(mocker)
+    _patch_exit_event(mocker)
 
-    # Mock Events: 
-    # exit_event: False (start), False (loop once), True (break)
-    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
-    mock_state.exit_event.is_set.side_effect = [False, False, True]
+    mock_video_service = mock.Mock()
+    mock_video_service.getImageRemote.side_effect = Exception("boom")
 
-    # Run
-    mock_zmq = mock.Mock()
-    sender = VideoSender(mock_zmq)
-    sender.socket = mock.Mock() # Mock the socket to verify send
-    
-    sender.video_rcv_loop(mock_service, "sub_id")
+    fake_session = mock.Mock()
+    fake_session.service.return_value = mock_video_service
+    mocker.patch.object(state, "qi_session", fake_session)
 
-    # Assertions
-    mock_state.active_event.wait.assert_called()
-    mock_service.getImageRemote.assert_called_with("sub_id")
-    sender.socket.send.assert_called_with(fake_image_data)
+    mocker.patch.object(
+        fake_session.service("ALVideoDevice"),
+        "subscribeCamera",
+        return_value="stream_name"
+    )
 
-def test_video_loop_exit_during_wait(zmq_context, mocker):
-    """
-    Test that the loop breaks immediately if exit_event is set while waiting.
-    """
-    mock_service = mock.Mock()
-    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
-    
-    # 1. Loop check: False (enter loop)
-    # 2. Wait happens (mock returns instantly)
-    # 3. Post-wait check: True (break)
-    mock_state.exit_event.is_set.side_effect = [False, True]
+    sender = VideoSender(zmq_context)
+    send_socket = mock.Mock()
+    sender.socket.send = send_socket
 
-    mock_zqm = mock.Mock()
-    sender = VideoSender(mock_zqm)
-    sender.video_rcv_loop(mock_service, "sub_id")
+    sender.start_video_rcv()
+    sender.video_rcv_loop(mock_video_service, "stream_name")
 
-    # Assert we never tried to get an image
-    mock_service.getImageRemote.assert_not_called()
-
-def test_video_loop_exception_handling(zmq_context, mocker):
-    """
-    Test that exceptions during image retrieval are caught and logged, 
-    and do not crash the thread.
-    """
-    mock_settings = mocker.patch("robot_interface.endpoints.video_sender.settings")
-    
-    mock_service = mock.Mock()
-    # First call raises Exception, Second call works (if we allowed it, but we exit)
-    mock_service.getImageRemote.side_effect = Exception("Camera disconnected")
-
-    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
-    # Loop runs once then exits
-    mock_state.exit_event.is_set.side_effect = [False, False, True]
-
-    mock_zmq = mock.Mock()
-    sender = VideoSender(mock_zmq)
-    sender.socket = mock.Mock()
-    
-    sender.video_rcv_loop(mock_service, "sub_id")
-
-    # Assertions
-    # Ensure loop didn't crash; it should have completed the iteration and checked exit_event
-    assert mock_state.exit_event.is_set.call_count >= 2
+    send_socket.assert_not_called()