use time.monotonic_ns() to measure timeouts

re-implement timeout similar to Circuitpython (None blocks, 0 doesn't)
NOTE: this is a breaking change for any code that uses it

bind() saves the bound address and port
listen() uses the saved address and port or uses defaults
some fixes for pylint/black

Author: Neradoc

adafruit_esp32spi/adafruit_esp32spi_socketpool.py

@@ -14,7 +14,7 @@
 from __future__ import annotations
 
 try:
-    from typing import TYPE_CHECKING, Optional
+    from typing import TYPE_CHECKING, Optional, Tuple
 
     if TYPE_CHECKING:
         from esp32spi.adafruit_esp32spi import ESP_SPIcontrol  # noqa: UP007
@@ -40,7 +40,7 @@ class SocketPool:
     SOCK_STREAM = const(1)
     SOCK_DGRAM = const(2)
     AF_INET = const(2)
-    SOL_SOCKET = const(0xfff)
+    SOL_SOCKET = const(0xFFF)
     SO_REUSEADDR = const(0x0004)
 
     # implementation specific constants
@@ -95,6 +95,7 @@ def __init__(
         self._type = type
         self._buffer = b""
         self._socknum = socknum if socknum is not None else self._interface.get_socket()
+        self._bound = ()
         self.settimeout(0)
 
     def __enter__(self):
@@ -156,12 +157,12 @@ def recv_into(self, buffer, nbytes: int = 0):
         if not 0 <= nbytes <= len(buffer):
             raise ValueError("nbytes must be 0 to len(buffer)")
 
-        last_read_time = time.monotonic()
+        last_read_time = time.monotonic_ns()
         num_to_read = len(buffer) if nbytes == 0 else nbytes
         num_read = 0
         while num_to_read > 0:
             # we might have read socket data into the self._buffer with:
-            # esp32spi_wsgiserver: socket_readline
+            # adafruit_wsgi.esp32spi_wsgiserver: socket_readline
             if len(self._buffer) > 0:
                 bytes_to_read = min(num_to_read, len(self._buffer))
                 buffer[num_read : num_read + bytes_to_read] = self._buffer[:bytes_to_read]
@@ -173,24 +174,38 @@ def recv_into(self, buffer, nbytes: int = 0):
 
             num_avail = self._available()
             if num_avail > 0:
-                last_read_time = time.monotonic()
-                bytes_read = self._interface.socket_read(self._socknum, min(num_to_read, num_avail))
+                last_read_time = time.monotonic_ns()
+                bytes_read = self._interface.socket_read(
+                    self._socknum, min(num_to_read, num_avail)
+                )
                 buffer[num_read : num_read + len(bytes_read)] = bytes_read
                 num_read += len(bytes_read)
                 num_to_read -= len(bytes_read)
             elif num_read > 0:
                 # We got a message, but there are no more bytes to read, so we can stop.
                 break
             # No bytes yet, or more bytes requested.
-            if self._timeout > 0 and time.monotonic() - last_read_time > self._timeout:
+
+            if self._timeout == 0:  # if in non-blocking mode, stop now.
+                break
+
+            # Time out if there's a positive timeout set.
+            delta = (time.monotonic_ns() - last_read_time) // 1_000_000
+            if self._timeout > 0 and delta > self._timeout:
                 raise OSError(errno.ETIMEDOUT)
         return num_read
 
     def settimeout(self, value):
-        """Set the read timeout for sockets.
-        If value is 0 socket reads will block until a message is available.
+        """Set the read timeout for sockets in seconds.
+        ``0`` means non-blocking. ``None`` means block indefinitely.
         """
-        self._timeout = value
+        if value is None:
+            self._timeout = -1
+        else:
+            if value < 0:
+                raise ValueError("Timeout cannot be a negative number")
+            # internally in milliseconds as an int
+            self._timeout = int(value * 1000)
 
     def _available(self):
         """Returns how many bytes of data are available to be read (up to the MAX_PACKET length)"""
@@ -230,35 +245,41 @@ def close(self):
 
     def setsockopt(self, *opts, **kwopts):
         """Dummy call for compatibility."""
-        # FIXME
-        pass
 
-    def listen(self, backlog):
-        """Dummy call for compatibility."""
-        # FIXME
-        # probably nothing to do actually
-        # maybe check that we have called bind or something ?
-        pass
+    def setblocking(self, flag: bool):
+        """Set the blocking behaviour of this socket.
+        :param bool flag: False means non-blocking, True means block indefinitely.
+        """
+        if flag:
+            self.settimeout(None)
+        else:
+            self.settimeout(0)
 
-    def setblocking(self, blocking):
-        """Dummy call for compatibility."""
-        # FIXME
-        # is this settimeout(0) ? (if True) or something else ?
-        pass
+    def bind(self, address: Tuple[str, int]):
+        """Bind a socket to an address"""
+        self._bound = address
 
-    def bind(self, host_port):
-        host, port = host_port
+    def listen(self, backlog: int):  # pylint: disable=unused-argument
+        """Set socket to listen for incoming connections.
+        :param int backlog: length of backlog queue for waiting connections (ignored)
+        """
+        if not self._bound:
+            self._bound = (self._interface.ip_address, 80)
+        port = self._bound[1]
         self._interface.start_server(port, self._socknum)
-        print(f"Binding to {self._socknum}")
 
     def accept(self):
+        """Accept a connection on a listening socket of type SOCK_STREAM,
+        creating a new socket of type SOCK_STREAM. Returns a tuple of
+        (new_socket, remote_address)
+        """
         client_sock_num = self._interface.socket_available(self._socknum)
         if client_sock_num != SocketPool.NO_SOCKET_AVAIL:
             sock = Socket(self._socket_pool, socknum=client_sock_num)
             # get remote information (addr and port)
             remote = self._interface.get_remote_data(client_sock_num)
-            IP_ADDRESS = "{}.{}.{}.{}".format(*remote['ip_addr'])
-            PORT = remote['port']
-            client_address = (IP_ADDRESS, PORT)
+            ip_address = "{}.{}.{}.{}".format(*remote["ip_addr"])
+            port = remote["port"]
+            client_address = (ip_address, port)
             return sock, client_address
         raise OSError(errno.ECONNRESET)