Centralize header normalization in RequestHeaders and simplify Request attributes

Move header normalization (underscore-to-hyphen, title-case) into
RequestHeaders.__init__ so callers don't need to pre-normalize.
Change headers and query_string from properties to plain attributes.
Rename _scheme to server_scheme to match server_name/server_port convention.

Author: davegaeddert

plain-observer/plain/observer/core.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import MutableMapping
+from collections.abc import Mapping, MutableMapping
 from enum import Enum
 from typing import TYPE_CHECKING, Any, cast
 
@@ -70,7 +70,9 @@ class Observer:
     SUMMARY_COOKIE_DURATION = 60 * 60 * 24 * 7  # 1 week in seconds
     PERSIST_COOKIE_DURATION = 60 * 60 * 24  # 1 day in seconds
 
-    def __init__(self, *, cookies: dict[str, str], headers: dict[str, str]) -> None:
+    def __init__(
+        self, *, cookies: Mapping[str, str], headers: Mapping[str, str]
+    ) -> None:
         self.cookies = cookies
         self.headers = headers
 

plain/plain/http/request.py

@@ -60,7 +60,7 @@ def __init__(
         path: str,
         headers: dict[str, str] | None = None,
         query_string: str = "",
-        scheme: str = "http",
+        server_scheme: str = "http",
         server_name: str = "",
         server_port: str = "",
         remote_addr: str = "",
@@ -75,16 +75,15 @@ def __init__(
         self.server_name = server_name
         self.server_port = server_port
         self.remote_addr = remote_addr
-        self._query_string = query_string
-        self._scheme = scheme
-        self._headers = headers or {}
+        self.query_string = query_string
+        self.server_scheme = server_scheme
+        self.headers = RequestHeaders(headers or {})
 
         # Parse content type, params, and encoding from headers
-        content_type_header = self._headers.get("Content-Type", "")
         self.content_type: str | None
         self.content_params: dict[str, str] | None
         self.content_type, self.content_params = parse_header_parameters(
-            content_type_header
+            self.headers.get("Content-Type", "")
         )
         self.encoding: str | None = None
         if "charset" in (self.content_params or {}):
@@ -115,13 +114,9 @@ def __deepcopy__(self, memo: dict[int, Any]) -> Request:
         memo[id(self)] = obj
         return obj
 
-    @cached_property
-    def headers(self) -> RequestHeaders:
-        return RequestHeaders(self._headers)
-
     @cached_property
     def query_params(self) -> QueryDict:
-        return QueryDict(self._query_string, encoding=self.encoding)
+        return QueryDict(self.query_string, encoding=self.encoding)
 
     @cached_property
     def cookies(self) -> dict[str, str]:
@@ -219,11 +214,6 @@ def client_ip(self) -> str:
                 return xff.split(",")[0].strip()
         return self.remote_addr
 
-    @property
-    def query_string(self) -> str:
-        """Return the raw query string from the request URL."""
-        return self._query_string
-
     @property
     def content_length(self) -> int:
         """Return the Content-Length header value, or 0 if not provided."""
@@ -306,10 +296,6 @@ def build_absolute_uri(self, location: str | None = None) -> str:
 
         return iri_to_uri(location) or ""
 
-    def _get_scheme(self) -> str:
-        """Return the URL scheme for the request."""
-        return self._scheme
-
     @property
     def scheme(self) -> str:
         if settings.HTTPS_PROXY_HEADER:
@@ -325,7 +311,7 @@ def scheme(self) -> str:
             if header_value is not None:
                 header_value, *_ = header_value.split(",", 1)
                 return "https" if header_value.strip() == secure_value else "http"
-        return self._get_scheme()
+        return self.server_scheme
 
     def is_https(self) -> bool:
         return self.scheme == "https"
@@ -505,11 +491,11 @@ def get_signed_cookie(
 
 
 class RequestHeaders(CaseInsensitiveMapping):
-    """Case-insensitive mapping of HTTP request headers.
-
-    Headers are expected to be pre-normalized to Title-Case by the
-    server or test client before being passed to Request.__init__.
-    """
+    def __init__(self, headers: dict[str, str]):
+        normalized = {
+            name.replace("_", "-").title(): value for name, value in headers.items()
+        }
+        super().__init__(normalized)
 
     def __getitem__(self, key: str) -> str:
         """Allow header lookup using underscores in place of hyphens."""

plain/plain/server/http/response.py

@@ -74,13 +74,11 @@ def create_request(
         elif hdr_name == "SCRIPT_NAME":
             script_name = hdr_value
 
-        # Convert to standard header name (Title-Case)
-        name = hdr_name.replace("_", "-").title()
         # Handle duplicate headers by joining with comma
-        if name in headers:
-            headers[name] = f"{headers[name]},{hdr_value}"
+        if hdr_name in headers:
+            headers[hdr_name] = f"{headers[hdr_name]},{hdr_value}"
         else:
-            headers[name] = hdr_value
+            headers[hdr_name] = hdr_value
 
     # Remote address
     if isinstance(client, str):
@@ -112,7 +110,7 @@ def create_request(
         path=path,
         headers=headers,
         query_string=req.query or "",
-        scheme=req.scheme,
+        server_scheme=req.scheme,
         server_name=server_name,
         server_port=server_port,
         remote_addr=remote_addr,

plain/plain/test/client.py

@@ -269,18 +269,12 @@ def _build_request(
             all_headers["Content-Type"] = content_type
             all_headers["Content-Length"] = str(len(data))
 
-        # Normalize header names to Title-Case so that direct dict lookups
-        # (e.g. _headers.get("Cookie")) work regardless of caller casing.
-        normalized_headers = {
-            k.replace("_", "-").title(): v for k, v in all_headers.items()
-        }
-
         request = Request(
             method=method,
             path=path,
-            headers=normalized_headers,
+            headers=all_headers,
             query_string=query_string,
-            scheme="https" if secure else "http",
+            server_scheme="https" if secure else "http",
             server_name=server_name,
             server_port=server_port or ("443" if secure else "80"),
             remote_addr="127.0.0.1",