uhttp-client 2.3.0__tar.gz → 2.3.1__tar.gz

uhttp_client-2.3.1/.github/workflows/tests.yml

@@ -0,0 +1,87 @@
+name: Tests
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main, v2]
+  pull_request:
+    branches: [main, v2]
+
+jobs:
+  test-ubuntu:
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 1
+      matrix:
+        python-version: ["3.10", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package
+        run: pip install .
+
+      - name: Install test dependencies
+        run: pip install uhttp-server
+
+      - name: Run unit tests
+        run: python -m unittest discover -v tests/
+
+  test-windows:
+    runs-on: windows-latest
+    strategy:
+      max-parallel: 1
+      matrix:
+        python-version: ["3.10", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package
+        run: pip install .
+
+      - name: Install test dependencies
+        run: pip install uhttp-server
+
+      - name: Run unit tests
+        run: python -m unittest discover -v tests/
+
+  micropython:
+    if: github.event_name == 'push'
+    needs: [test-ubuntu, test-windows]
+    runs-on: [self-hosted, Linux]
+    # One device, two maintained branches - queue instead of colliding, and
+    # never cancel: interrupting mpytool mid-operation wedges the REPL.
+    concurrency:
+      group: micropython-${{ matrix.device }}
+      cancel-in-progress: false
+    strategy:
+      fail-fast: false
+      matrix:
+        device: [ESP32]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        run: |
+          $HOME/actions-runner/.venv/bin/pip install -e .
+          $HOME/actions-runner/.venv/bin/pip install 'mpytool>=2.4.0'
+
+      - name: MicroPython tests (${{ matrix.device }})
+        run: |
+          export PATH="$HOME/actions-runner/.venv/bin:$PATH"
+          export MPY_TEST_PORT="$(cat $HOME/actions-runner/.config/mpytool/${{ matrix.device }})"
+          export MPY_WIFI_SSID="$(jq -r .ssid $HOME/actions-runner/.config/uhttp/wifi.json)"
+          export MPY_WIFI_PASSWORD="$(jq -r .password $HOME/actions-runner/.config/uhttp/wifi.json)"
+          python -m unittest tests.test_mpy_integration -v

{uhttp_client-2.3.0 → uhttp_client-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uhttp-client
-Version: 2.3.0
+Version: 2.3.1
 Summary: Micro HTTP client for Python and MicroPython
 Author-email: Pavel Revak <pavelrevak@gmail.com>
 License: MIT

{uhttp_client-2.3.0 → uhttp_client-2.3.1}/tests/test_event_mode.py

@@ -5,6 +5,7 @@ accept_body*() body delivery, and EVENT_ERROR surfacing.
 
 Uses raw TCP servers so we can produce exact framing and timing.
 """
+import errno
 import os
 import socket
 import tempfile
@@ -311,6 +312,55 @@ class TestEventModeNdjson(unittest.TestCase):
             server.stop()
 
 
+class _WindowsSelect:
+    """select() that rejects all-empty fd sets, the way Windows does.
+
+    POSIX happily waits on nothing; Windows needs at least one non-empty
+    set and answers WSAEINVAL (WinError 10022) otherwise. The client
+    reaches that call at STATE_COMPLETE, where read_sockets and
+    write_sockets are both empty but decoded records may still be queued.
+    """
+
+    def __init__(self, real):
+        self._real = real
+
+    def __call__(self, readers, writers, errors, timeout=None):
+        if not readers and not writers and not errors:
+            raise OSError(errno.EINVAL, 'An invalid argument was supplied')
+        return self._real(readers, writers, errors, timeout)
+
+
+class TestNothingToSelectOn(unittest.TestCase):
+    """Buffered output must survive having no socket left to watch."""
+
+    def test_trailing_record_survives_windows_empty_select(self):
+        # One recv carries the body and the EOF, so both records are decoded
+        # at once and the second is still queued after the first EVENT_DATA.
+        # By then the socket is out of read_sockets/write_sockets.
+        server = RawServer([
+            b'HTTP/1.1 200 OK\r\n'
+            b'Content-Type: application/x-ndjson\r\n'
+            b'Connection: close\r\n\r\n'
+            b'{"x": 1}\n{"y": 2}'], delay=0.0, close=True)
+        real_select = uhttp_client._select.select
+        uhttp_client._select.select = _WindowsSelect(real_select)
+        records = []
+        try:
+            client = uhttp_client.HttpClient(
+                '127.0.0.1', port=server.port, event_mode=True)
+            client.get('/', stream=True)
+            events = drive(
+                client,
+                on_headers=lambda c: c.accept_ndjson(),
+                on_data=lambda c: records.append(c.read_record()))
+            self.assertNotIn(EVENT_ERROR, events, client.error)
+            self.assertEqual(records, [{'x': 1}, {'y': 2}])
+            client.close()
+        finally:
+            uhttp_client._select.select = real_select
+            server.stop()
+
+
 class _ResetSocket:
     """Fake socket whose recv() raises a given OSError (e.g. ECONNRESET)."""
 

uhttp_client-2.3.1/tests/test_http_compliance.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""HTTP/1.1 conformance regressions found reviewing the client.
+
+Self-contained fixture on purpose: this file is meant to rebase cleanly onto
+branches that reorganise the shared test helpers.
+"""
+import errno
+import socket
+import threading
+import unittest
+
+from uhttp import client as uhttp_client
+
+
+class RawServer:
+    """Answers one connection with a fixed byte string."""
+
+    def __init__(self, response, host='127.0.0.1'):
+        self._response = response
+        self._sock = socket.socket()
+        self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._sock.bind((host, 0))
+        self._sock.listen(1)
+        self.port = self._sock.getsockname()[1]
+        self._thread = threading.Thread(target=self._serve, daemon=True)
+        self._thread.start()
+
+    def _serve(self):
+        try:
+            conn, _ = self._sock.accept()
+            conn.recv(4096)
+            conn.sendall(self._response)
+            try:
+                conn.shutdown(socket.SHUT_WR)
+                conn.settimeout(2.0)
+                while conn.recv(4096):
+                    pass
+            except OSError:
+                pass
+            conn.close()
+        except OSError:
+            pass
+        finally:
+            self.stop()
+
+    def stop(self):
+        try:
+            self._sock.close()
+        except OSError:
+            pass
+
+
+class TestBodylessResponses(unittest.TestCase):
+    """(9) HEAD / 204 / 304 never carry a body, whatever Content-Length says.
+
+    RFC 7230 3.3.3: the framing of those responses is fixed by the status or
+    the request method, so a Content-Length header must not be believed.
+    """
+
+    def _request(self, method, raw_response):
+        server = RawServer(raw_response)
+        try:
+            client = uhttp_client.HttpClient('127.0.0.1', port=server.port)
+            try:
+                return client.request(method, '/').wait(timeout=1)
+            finally:
+                client.close()
+        finally:
+            server.stop()
+
+    def test_head_with_content_length(self):
+        response = self._request(
+            'HEAD',
+            b'HTTP/1.1 200 OK\r\nContent-Length: 5\r\n'
+            b'Connection: close\r\n\r\n')
+        self.assertEqual(response.status, 200)
+        self.assertEqual(response.data, b'')
+
+    def test_204_with_content_length(self):
+        response = self._request(
+            'GET',
+            b'HTTP/1.1 204 No Content\r\nContent-Length: 5\r\n'
+            b'Connection: close\r\n\r\n')
+        self.assertEqual(response.status, 204)
+        self.assertEqual(response.data, b'')
+
+    def test_304_with_content_length(self):
+        response = self._request(
+            'GET',
+            b'HTTP/1.1 304 Not Modified\r\nContent-Length: 5\r\n'
+            b'Connection: close\r\n\r\n')
+        self.assertEqual(response.status, 304)
+        self.assertEqual(response.data, b'')
+
+
+# An address family no port implements, so socket() raises before any
+# connect: family -1 does NOT do that - CPython's socket.__init__ maps -1
+# to AF_INET, and the candidate then failed only because connect() to an
+# IPv6 literal happens to raise at once on POSIX. On Windows it does not,
+# so the client adopted the socket and sat in STATE_CONNECTING until the
+# test's own timeout.
+BAD_FAMILY = 12345
+
+
+class TestAddressFallback(unittest.TestCase):
+    """(10) getaddrinfo returns several addresses; all must be tried."""
+
+    def test_unusable_first_address_falls_back(self):
+        server = RawServer(
+            b'HTTP/1.1 200 OK\r\nContent-Length: 2\r\n'
+            b'Connection: close\r\n\r\nok')
+        original = uhttp_client._socket.getaddrinfo
+
+        def two_addresses(host, port, *args, **kwargs):
+            real = original('127.0.0.1', port, *args, **kwargs)
+            # A family socket() rejects outright, then the working address.
+            return [
+                (BAD_FAMILY, socket.SOCK_STREAM, 0, '', ('::1', port)),
+            ] + list(real)
+
+        uhttp_client._socket.getaddrinfo = two_addresses
+        try:
+            client = uhttp_client.HttpClient('localhost', port=server.port)
+            response = client.get('/').wait(timeout=2)
+            self.assertEqual(response.data, b'ok')
+            client.close()
+        finally:
+            uhttp_client._socket.getaddrinfo = original
+            server.stop()
+
+    def test_all_addresses_failing_raises_connection_error(self):
+        original = uhttp_client._socket.getaddrinfo
+
+        def only_bad(host, port, *args, **kwargs):
+            return [
+                (BAD_FAMILY, socket.SOCK_STREAM, 0, '', ('::1', port)),
+                (BAD_FAMILY, socket.SOCK_STREAM, 0, '', ('127.0.0.1', port)),
+            ]
+
+        uhttp_client._socket.getaddrinfo = only_bad
+        try:
+            client = uhttp_client.HttpClient('localhost', port=9)
+            with self.assertRaises(uhttp_client.HttpConnectionError):
+                client.get('/').wait(timeout=2)
+            client.close()
+        finally:
+            uhttp_client._socket.getaddrinfo = original
+
+
+class TestMalformedContentLength(unittest.TestCase):
+    """(11) A bad Content-Length is a response error, not a raw ValueError."""
+
+    def test_non_numeric_content_length(self):
+        server = RawServer(
+            b'HTTP/1.1 200 OK\r\nContent-Length: abc\r\n'
+            b'Connection: close\r\n\r\n')
+        try:
+            client = uhttp_client.HttpClient('127.0.0.1', port=server.port)
+            with self.assertRaises(uhttp_client.HttpResponseError):
+                client.get('/').wait(timeout=1)
+            # The state machine must not be left mid-request.
+            self.assertEqual(client.state, uhttp_client.STATE_IDLE)
+            client.close()
+        finally:
+            server.stop()
+
+    def test_client_is_reusable_after_a_bad_content_length(self):
+        server = RawServer(
+            b'HTTP/1.1 200 OK\r\nContent-Length: 1x\r\n'
+            b'Connection: close\r\n\r\n')
+        try:
+            client = uhttp_client.HttpClient('127.0.0.1', port=server.port)
+            with self.assertRaises(uhttp_client.HttpResponseError):
+                client.get('/').wait(timeout=1)
+            # Used to raise "Request already in progress" forever.
+            try:
+                client.get('/again')
+            except uhttp_client.HttpConnectionError:
+                pass  # server is gone; only the wedged state matters here
+            client.close()
+        finally:
+            server.stop()
+
+
+class TestHeaderOverride(unittest.TestCase):
+    """(12) A caller-supplied header replaces the default, whatever its case."""
+
+    def _header_lines(self, request, name):
+        prefix = name.lower().encode('ascii') + b':'
+        return [line for line in request.split(b'\r\n')
+                if line.lower().startswith(prefix)]
+
+    def test_canonical_case_host_is_not_duplicated(self):
+        client = uhttp_client.HttpClient('example.com')
+        try:
+            request = client._build_request(
+                'GET', '/', {'Host': 'vhost.example'})
+            lines = self._header_lines(request, 'Host')
+            self.assertEqual(len(lines), 1, b' | '.join(lines).decode())
+            self.assertEqual(lines[0], b'Host: vhost.example')
+        finally:
+            client.close()
+
+    def test_canonical_case_user_agent_is_not_duplicated(self):
+        client = uhttp_client.HttpClient('example.com')
+        try:
+            request = client._build_request(
+                'GET', '/', {'User-Agent': 'mine/1.0'})
+            self.assertEqual(len(self._header_lines(request, 'User-Agent')), 1)
+        finally:
+            client.close()
+
+    def test_canonical_case_content_type_is_not_duplicated(self):
+        client = uhttp_client.HttpClient('example.com')
+        try:
+            request = client._build_request(
+                'POST', '/', {'Content-Type': 'text/plain'}, data=b'x')
+            self.assertEqual(
+                len(self._header_lines(request, 'Content-Type')), 1)
+        finally:
+            client.close()
+
+
+class TestIpv6Url(unittest.TestCase):
+    """(13) Bracketed IPv6 literals are valid URLs (RFC 3986 3.2.2)."""
+
+    def test_ipv6_with_port(self):
+        host, port, path, use_ssl, auth = uhttp_client.parse_url(
+            'http://[::1]:8080/x')
+        self.assertEqual(host, '::1')
+        self.assertEqual(port, 8080)
+        self.assertEqual(path, '/x')
+
+    def test_ipv6_without_port(self):
+        host, port, path, use_ssl, auth = uhttp_client.parse_url(
+            'http://[::1]/x')
+        self.assertEqual(host, '::1')
+        self.assertEqual(port, 80)
+
+    def test_ipv6_https_default_port(self):
+        host, port, path, use_ssl, auth = uhttp_client.parse_url(
+            'https://[2001:db8::1]/')
+        self.assertEqual(host, '2001:db8::1')
+        self.assertEqual(port, 443)
+        self.assertTrue(use_ssl)
+
+    def test_ipv6_with_auth(self):
+        host, port, path, use_ssl, auth = uhttp_client.parse_url(
+            'http://user:pass@[::1]:8080/x')
+        self.assertEqual(host, '::1')
+        self.assertEqual(port, 8080)
+        self.assertEqual(auth, ('user', 'pass'))
+
+    def test_ipv6_client_sends_bare_host_header(self):
+        client = uhttp_client.HttpClient('http://[::1]:8080/')
+        try:
+            self.assertEqual(client.host, '::1')
+            self.assertEqual(client.port, 8080)
+        finally:
+            client.close()
+
+
+class TestPortableErrno(unittest.TestCase):
+    """(14) Every site must use the EWOULDBLOCK fallback constant."""
+
+    def test_no_site_reads_errno_ewouldblock_directly(self):
+        with open(uhttp_client.__file__) as handle:
+            source = handle.read()
+        below_fallback = source.split('EWOULDBLOCK = getattr', 1)[1]
+        offenders = [line.strip() for line in below_fallback.splitlines()
+                     if 'errno.EWOULDBLOCK' in line]
+        self.assertEqual(
+            offenders, [],
+            "some MicroPython ports do not define errno.EWOULDBLOCK")
+
+
+if __name__ == '__main__':
+    unittest.main()

{uhttp_client-2.3.0 → uhttp_client-2.3.1}/uhttp/client.py

@@ -20,6 +20,28 @@ MB = 2 ** 20
 # because some MicroPython ports do not define EWOULDBLOCK.
 EWOULDBLOCK = getattr(errno, 'EWOULDBLOCK', errno.EAGAIN)
 
+
+def _errnos(*names):
+    """Collect the errno values a port actually defines"""
+    values = []
+    for name in names:
+        value = getattr(errno, name, None)
+        if value is not None and value not in values:
+            values.append(value)
+    return tuple(values)
+
+
+# "No progress yet" rather than a failure: the non-blocking family plus
+# ENOENT, which MicroPython raises while an SSL handshake is in flight.
+WOULD_BLOCK_ERRNOS = _errnos(
+    'EAGAIN', 'EWOULDBLOCK', 'EINPROGRESS', 'EALREADY', 'ENOENT')
+
+
+def _would_block(err):
+    """True when an OSError only means the operation has not progressed"""
+    return err.errno in WOULD_BLOCK_ERRNOS
+
+
 CONNECT_TIMEOUT = 10
 TIMEOUT = 30
 
@@ -282,6 +304,17 @@ class _NdjsonDecoder(_RecordDecoder):
         return []
 
 
+def _has_header(headers, name):
+    """HTTP field names are case-insensitive, so 'Host' must hide 'host'"""
+    if name in headers:
+        return True
+    lowered = name.lower()
+    for key in headers:
+        if key.lower() == lowered:
+            return True
+    return False
+
+
 def _parse_header_line(line):
     try:
         line = line.decode('ascii')
@@ -326,16 +359,35 @@ def parse_url(url):
         else:
             auth = (auth_part, '')
 
-    if ':' in host_port:
+    # A bracketed IPv6 literal (RFC 3986 3.2.2) is full of colons, so the
+    # port can only be what follows the closing bracket.
+    port = None
+    if host_port.startswith('['):
+        end = host_port.find(']')
+        if end == -1:
+            raise HttpClientError(f"Unterminated IPv6 address: {host_port}")
+        host = host_port[1:end]
+        rest = host_port[end + 1:]
+        if rest.startswith(':'):
+            port = _parse_port(rest[1:])
+    elif ':' in host_port:
         host, port_str = host_port.rsplit(':', 1)
-        port = int(port_str)
+        port = _parse_port(port_str)
     else:
         host = host_port
+    if port is None:
         port = 443 if ssl else 80
 
     return host, port, path, ssl, auth
 
 
+def _parse_port(value):
+    try:
+        return int(value)
+    except ValueError as err:
+        raise HttpClientError(f"Invalid port: {value}") from err
+
+
 def _encode_query(query):
     if not query:
         return ''
@@ -356,12 +408,12 @@ def _encode_request_data(data, headers):
         return None
     if isinstance(data, (dict, list, tuple)):
         data = _json.dumps(data).encode('ascii')
-        if CONTENT_TYPE not in headers:
+        if not _has_header(headers, CONTENT_TYPE):
             headers[CONTENT_TYPE] = CONTENT_TYPE_JSON
     elif isinstance(data, str):
         data = data.encode('utf-8')
     elif isinstance(data, (bytes, bytearray, memoryview)):
-        if CONTENT_TYPE not in headers:
+        if not _has_header(headers, CONTENT_TYPE):
             headers[CONTENT_TYPE] = CONTENT_TYPE_OCTET_STREAM
     else:
         raise HttpClientError(f"Unsupported data type: {type(data).__name__}")
@@ -738,16 +790,16 @@ class HttpClient:
 
         full_path = path + _encode_query(query)
 
-        if HOST not in headers:
+        if not _has_header(headers, HOST):
             if self._port == 80 or (self._ssl_context and self._port == 443):
                 headers[HOST] = self._host
             else:
                 headers[HOST] = f"{self._host}:{self._port}"
 
-        if USER_AGENT not in headers:
+        if not _has_header(headers, USER_AGENT):
             headers[USER_AGENT] = USER_AGENT_VALUE
 
-        if encoded_data:
+        if encoded_data and not _has_header(headers, CONTENT_LENGTH):
             headers[CONTENT_LENGTH] = len(encoded_data)
 
         # Add Expect: 100-continue header if requested and there's data to send
@@ -761,7 +813,7 @@ class HttpClient:
 
         # Use request-specific auth if set, otherwise client's default
         auth = self._request_auth if self._request_auth is not None else self._auth
-        if auth and AUTHORIZATION not in headers:
+        if auth and not _has_header(headers, AUTHORIZATION):
             if self._digest_params:
                 # Digest auth
                 self._digest_nc += 1
@@ -813,31 +865,44 @@ class HttpClient:
         try:
             addr_info = _socket.getaddrinfo(
                 self._host, self._port, 0, _socket.SOCK_STREAM)
-            if not addr_info:
-                raise HttpConnectionError(
-                    f"Cannot resolve host: {self._host}")
-            family, socktype, proto, _, addr = addr_info[0]
-            sock = _socket.socket(family, socktype, proto)
-            sock.setblocking(False)
+        except OSError as err:
+            raise HttpConnectionError(f"Connect failed: {err}") from err
+        if not addr_info:
+            raise HttpConnectionError(f"Cannot resolve host: {self._host}")
+
+        # getaddrinfo may return both IPv6 and IPv4 records; a dual-stack
+        # host whose AAAA is unreachable must still connect over IPv4.
+        last_error = None
+        for family, socktype, proto, _, addr in addr_info:
             try:
-                sock.connect(addr)
-                # Connect completed immediately (e.g. loopback)
-                self._socket = sock
-                self._connect_complete()
+                sock, in_progress = self._open_socket(
+                    family, socktype, proto, addr)
             except OSError as err:
-                if err.errno in (
-                        errno.EINPROGRESS, errno.EAGAIN,
-                        errno.EALREADY, errno.EWOULDBLOCK):
-                    self._socket = sock
-                    self._state = STATE_CONNECTING
-                else:
-                    sock.close()
-                    raise HttpConnectionError(
-                        f"Connect failed: {err}") from err
-        except HttpConnectionError:
-            raise
+                last_error = err
+                continue
+            # Adopted: from here a failure belongs to this connection, not
+            # to the candidate list, so it must not try the next address.
+            self._socket = sock
+            if in_progress:
+                self._state = STATE_CONNECTING
+            else:
+                self._connect_complete()
+            return
+        raise HttpConnectionError(f"Connect failed: {last_error}")
+
+    @staticmethod
+    def _open_socket(family, socktype, proto, addr):
+        """Start a non-blocking connect; (socket, still_connecting)"""
+        sock = _socket.socket(family, socktype, proto)
+        try:
+            sock.setblocking(False)
+            sock.connect(addr)
         except OSError as err:
-            raise HttpConnectionError(f"Connect failed: {err}") from err
+            if not _would_block(err):
+                sock.close()
+                raise
+            return sock, True
+        return sock, False  # completed immediately (e.g. loopback)
 
     def _connect_complete(self):
         """TCP connection established, start SSL or proceed to sending"""
@@ -901,7 +966,7 @@ class HttpClient:
             # implicitly during first send/recv
             pass
         except OSError as err:
-            if err.errno in (errno.EAGAIN, EWOULDBLOCK, errno.ENOENT):
+            if _would_block(err):
                 self._ssl_want_read = True  # MicroPython
                 return
             self._close()
@@ -992,14 +1057,39 @@ class HttpClient:
 
         self._body_reader = self._make_body_reader()
 
+    def _is_bodyless_response(self):
+        """RFC 7230 3.3.3: status or method fixes the framing as empty.
+
+        Responses to HEAD, and 1xx/204/304 responses, never carry a body -
+        any Content-Length they advertise describes what a GET would have
+        returned, and waiting for it would hang until the timeout.
+        """
+        status = self._response_status
+        if status is not None and (status < 200 or status in (204, 304)):
+            return True
+        method = self._request_method
+        return method is not None and method.upper() == 'HEAD'
+
+    def _content_length(self):
+        """Parsed Content-Length, or None when absent"""
+        value = self._response_headers.get(CONTENT_LENGTH)
+        if value is None:
+            return None
+        value = value.strip()
+        if not value.isdigit():
+            raise HttpResponseError(f"Invalid Content-Length: {value}")
+        return int(value)
+
     def _make_body_reader(self):
         """Select a body framing strategy based on response headers."""
+        if self._is_bodyless_response():
+            return _LengthBodyReader(0)
         te = self._response_headers.get(TRANSFER_ENCODING, '').lower()
         if CHUNKED in te:
             return _ChunkedBodyReader()
-        cl = self._response_headers.get(CONTENT_LENGTH)
-        if cl is not None:
-            return _LengthBodyReader(int(cl))
+        length = self._content_length()
+        if length is not None:
+            return _LengthBodyReader(length)
         if self._request_stream:
             # Streaming request without framing: read until the server closes
             # the connection (MJPEG, SSE, close-delimited bodies).
@@ -1010,9 +1100,11 @@ class HttpClient:
 
     def _check_response_length(self):
         """Fast-fail when the advertised Content-Length is too large."""
-        cl = self._response_headers.get(CONTENT_LENGTH)
-        if cl is not None and int(cl) > self._max_response_length:
-            raise HttpResponseError(f"Response too large: {cl}")
+        if self._is_bodyless_response():
+            return
+        length = self._content_length()
+        if length is not None and length > self._max_response_length:
+            raise HttpResponseError(f"Response too large: {length}")
 
     def _feed_body(self):
         """Feed buffered raw bytes through the body reader into self._body."""
@@ -1141,9 +1233,7 @@ class HttpClient:
         except (_ssl.SSLWantReadError, _ssl.SSLWantWriteError):
             return False
         except OSError as err:
-            if err.errno in (errno.EAGAIN, EWOULDBLOCK, errno.ENOENT):
-                # EAGAIN/EWOULDBLOCK: no data yet (non-blocking; the two
-                # differ on Windows). ENOENT: MicroPython SSL would-block.
+            if _would_block(err):
                 return False
             # A close-delimited body (EOF reader) ends when the connection
             # ends. The termination may surface as an empty read OR an error
@@ -1222,8 +1312,8 @@ class HttpClient:
             except (_ssl.SSLWantReadError, _ssl.SSLWantWriteError):
                 break
             except OSError as err:
-                if err.errno in (errno.EAGAIN, EWOULDBLOCK):
-                    break  # send buffer full (EWOULDBLOCK differs on Windows)
+                if _would_block(err):
+                    break  # send buffer full
                 raise HttpConnectionError(f"Send failed: {err}") from err
 
         if not self._send_buffer:
@@ -1690,11 +1780,19 @@ class HttpClient:
         else:
             select_timeout = timeout
 
+        read_socks = self.read_sockets
+        write_socks = self.write_sockets
+        if not read_socks and not write_socks:
+            # Nothing left to watch: at STATE_COMPLETE the socket is out of
+            # both lists while decoded records may still be queued. Deliver
+            # them - waiting on nothing cannot help, and Windows' select()
+            # rejects all-empty sets outright (WinError 10022), which turned
+            # a queued record into EVENT_ERROR.
+            return self.process_events([], [])
+
         try:
             r, w, x = _select.select(
-                self.read_sockets,
-                self.write_sockets,
-                self.write_sockets, select_timeout)
+                read_socks, write_socks, write_socks, select_timeout)
         except (OSError, ValueError) as err:
             self._error = f"select failed: {err}"
             self._close()

{uhttp_client-2.3.0 → uhttp_client-2.3.1}/uhttp_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uhttp-client
-Version: 2.3.0
+Version: 2.3.1
 Summary: Micro HTTP client for Python and MicroPython
 Author-email: Pavel Revak <pavelrevak@gmail.com>
 License: MIT

{uhttp_client-2.3.0 → uhttp_client-2.3.1}/uhttp_client.egg-info/SOURCES.txt

@@ -2,7 +2,6 @@
 LICENSE
 README.md
 pyproject.toml
-.github/workflows/micropython.yml
 .github/workflows/publish.yml
 .github/workflows/tests.yml
 examples/client_async.py
@@ -19,6 +18,7 @@ tests/test_cli.py
 tests/test_cookies.py
 tests/test_errors.py
 tests/test_event_mode.py
+tests/test_http_compliance.py
 tests/test_integration.py
 tests/test_keepalive.py
 tests/test_mpy_integration.py
@@ -30,4 +30,6 @@ uhttp_client.egg-info/PKG-INFO
 uhttp_client.egg-info/SOURCES.txt
 uhttp_client.egg-info/dependency_links.txt
 uhttp_client.egg-info/entry_points.txt
+uhttp_client.egg-info/scm_file_list.json
+uhttp_client.egg-info/scm_version.json
 uhttp_client.egg-info/top_level.txt

uhttp_client-2.3.1/uhttp_client.egg-info/scm_file_list.json

@@ -0,0 +1,32 @@
+{
+  "files": [
+    ".github/workflows/publish.yml",
+    ".github/workflows/tests.yml",
+    ".gitignore",
+    "LICENSE",
+    "README.md",
+    "examples/client_async.py",
+    "examples/client_basic.py",
+    "examples/client_https.py",
+    "examples/client_stream.py",
+    "pyproject.toml",
+    "tests/__init__.py",
+    "tests/test_100_continue.py",
+    "tests/test_async.py",
+    "tests/test_auth.py",
+    "tests/test_basic.py",
+    "tests/test_body_framing.py",
+    "tests/test_cli.py",
+    "tests/test_cookies.py",
+    "tests/test_errors.py",
+    "tests/test_event_mode.py",
+    "tests/test_http_compliance.py",
+    "tests/test_integration.py",
+    "tests/test_keepalive.py",
+    "tests/test_mpy_integration.py",
+    "tests/test_nonblocking_connect.py",
+    "tests/test_unit.py",
+    "uhttp/cli.py",
+    "uhttp/client.py"
+  ]
+}

uhttp_client-2.3.1/uhttp_client.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.3.1",
+  "distance": 0,
+  "node": "g6a6a5f49de988d4a1c41cb2710d6b3d6aed05d26",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-15"
+}

uhttp_client-2.3.0/.github/workflows/micropython.yml

@@ -1,39 +0,0 @@
-name: MicroPython Integration
-
-on:
-  workflow_dispatch:
-  push:
-    branches: [main]
-
-jobs:
-  unit-tests:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
-      - run: pip install -e .
-      - run: pip install uhttp-server
-      - run: python -m unittest discover tests/ -v
-
-  micropython:
-    runs-on: [self-hosted, Linux]
-    needs: unit-tests
-    strategy:
-      fail-fast: false
-      matrix:
-        device: [ESP32]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install package
-        run: $HOME/actions-runner/.venv/bin/pip install -e .
-
-      - name: MicroPython tests (${{ matrix.device }})
-        run: |
-          export PATH="$HOME/actions-runner/.venv/bin:$PATH"
-          export MPY_TEST_PORT="$(cat $HOME/actions-runner/.config/mpytool/${{ matrix.device }})"
-          export MPY_WIFI_SSID="$(jq -r .ssid $HOME/actions-runner/.config/uhttp/wifi.json)"
-          export MPY_WIFI_PASSWORD="$(jq -r .password $HOME/actions-runner/.config/uhttp/wifi.json)"
-          python -m unittest tests.test_mpy_integration -v

uhttp_client-2.3.0/.github/workflows/tests.yml

@@ -1,33 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      max-parallel: 1
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-        python-version: ["3.10", "3.14"]
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install package
-        run: pip install .
-
-      - name: Install test dependencies
-        run: pip install uhttp-server
-
-      - name: Run unit tests
-        run: python -m unittest discover -v tests/