add the ability to specify a timeout when constructing osc servers. Closes #170

Author: attwad

README.rst

@@ -73,7 +73,7 @@ Simple client
         help="The port the OSC server is listening on")
     args = parser.parse_args()
 
-    client = udp_client.SimpleUDPClient(args.ip, args.port)
+    client = udp_client.SimpleUDPClient(args.ip, args.port, timeout=10)
 
     for x in range(10):
       client.send_message("/filter", random.random())
@@ -117,7 +117,7 @@ Simple server
     dispatcher.map("/logvolume", print_compute_handler, "Log volume", math.log)
 
     server = osc_server.ThreadingOSCUDPServer(
-        (args.ip, args.port), dispatcher)
+        (args.ip, args.port), dispatcher, timeout=10)
     print("Serving on {}".format(server.server_address))
     server.serve_forever()
 

pythonosc/osc_server.py

@@ -63,16 +63,19 @@ def __init__(
         server_address: Tuple[str, int],
         dispatcher: Dispatcher,
         bind_and_activate: bool = True,
+        timeout: float | None = None,
     ) -> None:
         """Initialize
 
         Args:
             server_address: IP and port of server
             dispatcher: Dispatcher this server will use
             (optional) bind_and_activate: default=True defines if the server has to start on call of constructor
+            (optional) timeout: Default timeout in seconds for socket operations
         """
         super().__init__(server_address, _UDPHandler, bind_and_activate)
         self._dispatcher = dispatcher
+        self.timeout = timeout
 
     def verify_request(
         self, request: _RequestType, client_address: _AddressType

pythonosc/tcp_client.py

@@ -22,20 +22,23 @@ def __init__(
         port: int,
         family: socket.AddressFamily = socket.AF_INET,
         mode: str = MODE_1_1,
+        timeout: float | None = 30.0,
     ) -> None:
         """Initialize client
 
         Args:
             address: IP address of server
             port: Port of server
             family: address family parameter (passed to socket.getaddrinfo)
+            timeout: Default timeout in seconds for socket operations
         """
         self.address = address
         self.port = port
         self.family = family
         self.mode = mode
+        self._timeout = timeout
         self.socket = socket.socket(self.family, socket.SOCK_STREAM)
-        self.socket.settimeout(30)
+        self.socket.settimeout(timeout)
         self.socket.connect((address, port))
 
     def __enter__(self):
@@ -56,20 +59,21 @@ def send(self, content: Union[OscMessage, OscBundle]) -> None:
             b = struct.pack("!I", len(content.dgram))
             self.socket.sendall(b + content.dgram)
 
-    def receive(self, timeout: int = 30) -> List[bytes]:
-        self.socket.settimeout(timeout)
+    def receive(self, timeout: float | None = None) -> List[bytes]:
+        effective_timeout = timeout if timeout is not None else self._timeout
+        self.socket.settimeout(effective_timeout)
         if self.mode == MODE_1_1:
             try:
                 buf = self.socket.recv(4096)
-            except TimeoutError:
+            except (TimeoutError, socket.timeout):
                 return []
             if not buf:
                 return []
             # If the last byte is not an END marker there could be more data coming
             while buf[-1] != 192:
                 try:
                     newbuf = self.socket.recv(4096)
-                except TimeoutError:
+                except (TimeoutError, socket.timeout):
                     break
                 if not newbuf:
                     # Maybe should raise an exception here?
@@ -80,13 +84,13 @@ def receive(self, timeout: int = 30) -> List[bytes]:
             buf = b""
             try:
                 lengthbuf = self.socket.recv(4)
-            except TimeoutError:
+            except (TimeoutError, socket.timeout):
                 return []
             (length,) = struct.unpack("!I", lengthbuf)
             while length > 0:
                 try:
                     newbuf = self.socket.recv(length)
-                except TimeoutError:
+                except (TimeoutError, socket.timeout):
                     return []
                 if not newbuf:
                     return []
@@ -116,7 +120,7 @@ def send_message(
         msg = build_msg(address, value)
         return self.send(msg)
 
-    def get_messages(self, timeout: int = 30) -> Generator:
+    def get_messages(self, timeout: float | None = None) -> Generator:
         r = self.receive(timeout)
         while r:
             for m in r:
@@ -129,7 +133,7 @@ class TCPDispatchClient(SimpleTCPClient):
 
     dispatcher = Dispatcher()
 
-    def handle_messages(self, timeout_sec: int = 30) -> None:
+    def handle_messages(self, timeout_sec: float | None = None) -> None:
         """Wait :int:`timeout` seconds for a message from the server and process each message with the registered
         handlers.  Continue until a timeout occurs.
 
@@ -152,18 +156,21 @@ def __init__(
         port: int,
         family: socket.AddressFamily = socket.AF_INET,
         mode: str = MODE_1_1,
+        timeout: float | None = 30.0,
     ) -> None:
         """Initialize client
 
         Args:
             address: IP address of server
             port: Port of server
             family: address family parameter (passed to socket.getaddrinfo)
+            timeout: Default timeout in seconds for socket operations
         """
         self.address: str = address
         self.port: int = port
         self.mode: str = mode
         self.family: socket.AddressFamily = family
+        self._timeout = timeout
 
     def __await__(self):
         async def closure():
@@ -197,19 +204,22 @@ async def send(self, content: Union[OscMessage, OscBundle]) -> None:
             self.writer.write(b + content.dgram)
         await self.writer.drain()
 
-    async def receive(self, timeout: int = 30) -> List[bytes]:
+    async def receive(self, timeout: float | None = None) -> List[bytes]:
+        effective_timeout = timeout if timeout is not None else self._timeout
         if self.mode == MODE_1_1:
             try:
-                buf = await asyncio.wait_for(self.reader.read(4096), timeout)
-            except TimeoutError:
+                buf = await asyncio.wait_for(self.reader.read(4096), effective_timeout)
+            except (TimeoutError, asyncio.TimeoutError):
                 return []
             if not buf:
                 return []
             # If the last byte is not an END marker there could be more data coming
             while buf[-1] != 192:
                 try:
-                    newbuf = await asyncio.wait_for(self.reader.read(4096), timeout)
-                except TimeoutError:
+                    newbuf = await asyncio.wait_for(
+                        self.reader.read(4096), effective_timeout
+                    )
+                except (TimeoutError, asyncio.TimeoutError):
                     break
                 if not newbuf:
                     # Maybe should raise an exception here?
@@ -219,15 +229,19 @@ async def receive(self, timeout: int = 30) -> List[bytes]:
         else:
             buf = b""
             try:
-                lengthbuf = await asyncio.wait_for(self.reader.read(4), timeout)
-            except TimeoutError:
+                lengthbuf = await asyncio.wait_for(
+                    self.reader.read(4), effective_timeout
+                )
+            except (TimeoutError, asyncio.TimeoutError):
                 return []
 
             (length,) = struct.unpack("!I", lengthbuf)
             while length > 0:
                 try:
-                    newbuf = await asyncio.wait_for(self.reader.read(length), timeout)
-                except TimeoutError:
+                    newbuf = await asyncio.wait_for(
+                        self.reader.read(length), effective_timeout
+                    )
+                except (TimeoutError, asyncio.TimeoutError):
                     return []
                 if not newbuf:
                     return []
@@ -250,8 +264,9 @@ def __init__(
         port: int,
         family: socket.AddressFamily = socket.AF_INET,
         mode: str = MODE_1_1,
+        timeout: float | None = 30.0,
     ):
-        super().__init__(address, port, family, mode)
+        super().__init__(address, port, family, mode, timeout)
 
     async def send_message(
         self, address: str, value: Union[ArgValue, Iterable[ArgValue]] = ""
@@ -265,7 +280,7 @@ async def send_message(
         msg = build_msg(address, value)
         return await self.send(msg)
 
-    async def get_messages(self, timeout: int = 30) -> AsyncGenerator:
+    async def get_messages(self, timeout: float | None = None) -> AsyncGenerator:
         r = await self.receive(timeout)
         while r:
             for m in r:
@@ -278,7 +293,7 @@ class AsyncDispatchTCPClient(AsyncTCPClient):
 
     dispatcher = Dispatcher()
 
-    async def handle_messages(self, timeout: int = 30) -> None:
+    async def handle_messages(self, timeout: float | None = None) -> None:
         """Wait :int:`timeout` seconds for a message from the server and process each message with the registered
         handlers.  Continue until a timeout occurs.
 

pythonosc/test/test_osc_server.py

@@ -112,5 +112,13 @@ def respond(*args, **kwargs):
         )
 
 
+class TestOscUdpServer(unittest.TestCase):
+    @unittest.mock.patch("socket.socket")
+    def test_init_timeout(self, mock_socket_ctor):
+        dispatcher = unittest.mock.Mock()
+        server = osc_server.OSCUDPServer(("127.0.0.1", 0), dispatcher, timeout=10.0)
+        self.assertEqual(server.timeout, 10.0)
+
+
 if __name__ == "__main__":
     unittest.main()

pythonosc/test/test_udp_client.py

@@ -64,5 +64,30 @@ def test_context_manager(self, mock_socket_ctor):
         self.assertTrue(mock_socket.close.called)
 
 
+class TestUdpClientTimeout(unittest.TestCase):
+    @mock.patch("socket.socket")
+    def test_init_timeout(self, mock_socket_ctor):
+        mock_socket = mock_socket_ctor.return_value
+        client = udp_client.UDPClient("::1", 31337, timeout=10.0)
+        self.assertEqual(client._timeout, 10.0)
+        mock_socket.settimeout.assert_any_call(10.0)
+
+    @mock.patch("socket.socket")
+    def test_receive_default_timeout(self, mock_socket_ctor):
+        mock_socket = mock_socket_ctor.return_value
+        client = udp_client.UDPClient("::1", 31337, timeout=10.0)
+        mock_socket.recv.return_value = b"data"
+        client.receive()
+        mock_socket.settimeout.assert_called_with(10.0)
+
+    @mock.patch("socket.socket")
+    def test_receive_override_timeout(self, mock_socket_ctor):
+        mock_socket = mock_socket_ctor.return_value
+        client = udp_client.UDPClient("::1", 31337, timeout=10.0)
+        mock_socket.recv.return_value = b"data"
+        client.receive(timeout=5.0)
+        mock_socket.settimeout.assert_called_with(5.0)
+
+
 if __name__ == "__main__":
     unittest.main()

pythonosc/udp_client.py

@@ -25,6 +25,7 @@ def __init__(
         port: int,
         allow_broadcast: bool = False,
         family: socket.AddressFamily = socket.AF_UNSPEC,
+        timeout: float | None = None,
     ) -> None:
         """Initialize client
 
@@ -36,6 +37,7 @@ def __init__(
             port: Port of server
             allow_broadcast: Allow for broadcast transmissions
             family: address family parameter (passed to socket.getaddrinfo)
+            timeout: Default timeout in seconds for socket operations
         """
 
         for addr in socket.getaddrinfo(
@@ -50,6 +52,10 @@ def __init__(
             break
 
         self._sock.setblocking(False)
+        if timeout is not None:
+            self._sock.settimeout(timeout)
+        self._timeout = timeout
+
         if allow_broadcast:
             self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
         self._address = address
@@ -75,16 +81,21 @@ def send(self, content: Union[OscMessage, OscBundle]) -> None:
         """
         self._sock.sendto(content.dgram, (self._address, self._port))
 
-    def receive(self, timeout: int = 30) -> bytes:
+    def receive(self, timeout: float | None = None) -> bytes:
         """Wait :int:`timeout` seconds for a message an return the raw bytes
 
         Args:
-            timeout: Number of seconds to wait for a message
+            timeout: Number of seconds to wait for a message.
+                     If None, uses the default timeout set in __init__.
         """
-        self._sock.settimeout(timeout)
+        if timeout is not None:
+            self._sock.settimeout(timeout)
+        elif self._timeout is not None:
+            self._sock.settimeout(self._timeout)
+
         try:
             return self._sock.recv(4096)
-        except TimeoutError:
+        except (TimeoutError, socket.timeout, BlockingIOError):
             return b""
 
 
@@ -111,11 +122,12 @@ def send_message(
         msg = builder.build()
         self.send(msg)
 
-    def get_messages(self, timeout: int = 30) -> Generator:
+    def get_messages(self, timeout: float | None = None) -> Generator:
         """Wait :int:`timeout` seconds for a message from the server and convert it to a :class:`OscMessage`
 
         Args:
-            timeout: Time in seconds to wait for a message
+            timeout: Time in seconds to wait for a message.
+                     If None, uses the default timeout set in __init__.
         """
         msg = self.receive(timeout)
         while msg:
@@ -128,12 +140,13 @@ class DispatchClient(SimpleUDPClient):
 
     dispatcher = Dispatcher()
 
-    def handle_messages(self, timeout: int = 30) -> None:
+    def handle_messages(self, timeout: float | None = None) -> None:
         """Wait :int:`timeout` seconds for a message from the server and process each message with the registered
         handlers.  Continue until a timeout occurs.
 
         Args:
-            timeout: Time in seconds to wait for a message
+            timeout: Time in seconds to wait for a message.
+                     If None, uses the default timeout set in __init__.
         """
         msg = self.receive(timeout)
         while msg: