deal with case-insensitive headers

Author: keelerm84

ld_eventsource/actions.py

@@ -1,7 +1,7 @@
 import json
-from typing import Any, Dict, Optional
+from typing import Optional
 
-from ld_eventsource.errors import ExceptionWithHeaders
+from ld_eventsource.errors import ExceptionWithHeaders, Headers
 
 
 class Action:
@@ -118,15 +118,15 @@ class Start(Action):
     emitted with the headers from the new connection, which may differ from the previous one.
     """
 
-    def __init__(self, headers: Optional[Dict[str, Any]] = None):
+    def __init__(self, headers: Optional[Headers] = None):
         self._headers = headers
 
     @property
-    def headers(self) -> Optional[Dict[str, Any]]:
+    def headers(self) -> Optional[Headers]:
         """
         The HTTP response headers from the stream connection, if available.
 
-        The headers dict uses case-insensitive keys (via urllib3's HTTPHeaderDict).
+        Header name lookups are case-insensitive per RFC 7230.
 
         :return: the response headers, or ``None`` if not available
         """

ld_eventsource/async_http.py

@@ -1,11 +1,11 @@
 import asyncio
 from logging import Logger
-from typing import Any, AsyncIterator, Callable, Dict, Optional, Tuple
+from typing import AsyncIterator, Callable, Optional, Tuple
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
 import aiohttp
 
-from ld_eventsource.errors import HTTPContentTypeError, HTTPStatusError
+from ld_eventsource.errors import HTTPContentTypeError, HTTPStatusError, Headers
 
 _CHUNK_SIZE = 10000
 
@@ -64,7 +64,7 @@ async def _get_session(self) -> aiohttp.ClientSession:
 
     async def connect(
         self, last_event_id: Optional[str]
-    ) -> Tuple[AsyncIterator[bytes], Callable, Dict[str, Any]]:
+    ) -> Tuple[AsyncIterator[bytes], Callable, Headers]:
         url = self.__params.url
         if self.__params.query_params is not None:
             qp = self.__params.query_params()
@@ -98,7 +98,7 @@ async def connect(
         session = await self._get_session()
         resp = await session.get(url, **request_options)
 
-        response_headers: Dict[str, Any] = dict(resp.headers)
+        response_headers = resp.headers
 
         if resp.status >= 400 or resp.status == 204:
             await resp.release()

ld_eventsource/config/async_connect_strategy.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from logging import Logger
-from typing import Any, AsyncIterator, Callable, Dict, Optional
+from typing import AsyncIterator, Callable, Optional
+
+from ld_eventsource.errors import Headers
 
 
 class AsyncConnectStrategy:
@@ -89,7 +91,7 @@ def __init__(
         self,
         stream: AsyncIterator[bytes],
         closer: Optional[Callable],
-        headers: Optional[Dict[str, Any]] = None,
+        headers: Optional[Headers] = None,
     ):
         self.__stream = stream
         self.__closer = closer
@@ -103,9 +105,11 @@ def stream(self) -> AsyncIterator[bytes]:
         return self.__stream
 
     @property
-    def headers(self) -> Optional[Dict[str, Any]]:
+    def headers(self) -> Optional[Headers]:
         """
         The HTTP response headers, if available.
+
+        Header name lookups are case-insensitive per RFC 7230.
         """
         return self.__headers
 

ld_eventsource/config/connect_strategy.py

@@ -2,10 +2,11 @@
 
 from dataclasses import dataclass
 from logging import Logger
-from typing import Any, Callable, Dict, Iterator, Optional, Union
+from typing import Callable, Iterator, Optional, Union
 
 from urllib3 import PoolManager
 
+from ld_eventsource.errors import Headers
 from ld_eventsource.http import (DynamicQueryParams, _HttpClientImpl,
                                  _HttpConnectParams)
 
@@ -96,7 +97,7 @@ class ConnectionResult:
     The return type of :meth:`ConnectionClient.connect()`.
     """
 
-    def __init__(self, stream: Iterator[bytes], closer: Optional[Callable], headers: Optional[Dict[str, Any]] = None):
+    def __init__(self, stream: Iterator[bytes], closer: Optional[Callable], headers: Optional[Headers] = None):
         self.__stream = stream
         self.__closer = closer
         self.__headers = headers
@@ -109,14 +110,14 @@ def stream(self) -> Iterator[bytes]:
         return self.__stream
 
     @property
-    def headers(self) -> Optional[Dict[str, Any]]:
+    def headers(self) -> Optional[Headers]:
         """
         The HTTP response headers, if available.
 
         For HTTP connections, this contains the headers from the SSE stream response.
         For non-HTTP connections, this will be ``None``.
 
-        The headers dict uses case-insensitive keys (via urllib3's HTTPHeaderDict).
+        Header name lookups are case-insensitive per RFC 7230.
         """
         return self.__headers
 

ld_eventsource/errors.py

@@ -1,4 +1,27 @@
-from typing import Any, Dict, Optional, Protocol, runtime_checkable
+from typing import Any, Iterator, Optional, Protocol, Tuple, runtime_checkable
+
+
+class Headers(Protocol):
+    """
+    A case-insensitive mapping of HTTP response headers.
+
+    Header name lookups are case-insensitive per RFC 7230, so
+    ``headers.get('content-type')`` and ``headers.get('Content-Type')``
+    return the same value. The concrete type returned depends on the HTTP
+    backend in use and should not be relied upon directly.
+    """
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Return the value for *key* (case-insensitive), or *default*."""
+        ...
+
+    def __getitem__(self, key: str) -> Any: ...
+
+    def __contains__(self, key: object) -> bool: ...
+
+    def __iter__(self) -> Iterator[str]: ...
+
+    def items(self) -> Any: ...
 
 
 @runtime_checkable
@@ -11,7 +34,7 @@ class ExceptionWithHeaders(Protocol):
     """
 
     @property
-    def headers(self) -> Optional[Dict[str, Any]]:
+    def headers(self) -> Optional[Headers]:
         """The HTTP response headers associated with this exception."""
         raise NotImplementedError
 
@@ -24,7 +47,7 @@ class HTTPStatusError(Exception):
     When available, the response headers are accessible via the :attr:`headers` property.
     """
 
-    def __init__(self, status: int, headers: Optional[Dict[str, Any]] = None):
+    def __init__(self, status: int, headers: Optional[Headers] = None):
         super().__init__("HTTP error %d" % status)
         self._status = status
         self._headers = headers
@@ -34,8 +57,8 @@ def status(self) -> int:
         return self._status
 
     @property
-    def headers(self) -> Optional[Dict[str, Any]]:
-        """The HTTP response headers, if available."""
+    def headers(self) -> Optional[Headers]:
+        """The HTTP response headers, if available. Header names are case-insensitive."""
         return self._headers
 
 
@@ -47,7 +70,7 @@ class HTTPContentTypeError(Exception):
     When available, the response headers are accessible via the :attr:`headers` property.
     """
 
-    def __init__(self, content_type: str, headers: Optional[Dict[str, Any]] = None):
+    def __init__(self, content_type: str, headers: Optional[Headers] = None):
         super().__init__("invalid content type \"%s\"" % content_type)
         self._content_type = content_type
         self._headers = headers
@@ -57,6 +80,6 @@ def content_type(self) -> str:
         return self._content_type
 
     @property
-    def headers(self) -> Optional[Dict[str, Any]]:
-        """The HTTP response headers, if available."""
+    def headers(self) -> Optional[Headers]:
+        """The HTTP response headers, if available. Header names are case-insensitive."""
         return self._headers