Rename request.meta to request.environ, add request.query_string

Author: davegaeddert

plain/plain/http/multipartparser.py

@@ -63,16 +63,16 @@ class MultiPartParser:
 
     def __init__(
         self,
-        meta: dict[str, Any],
+        environ: dict[str, Any],
         input_data: Any,
         upload_handlers: list[FileUploadHandler],
         encoding: str | None = None,
     ):
         """
         Initialize the MultiPartParser object.
 
-        :meta:
-            The standard ``meta`` dictionary in Plain request objects.
+        :environ:
+            The WSGI environ dictionary from the request.
         :input_data:
             The raw post data, as a file-like object.
         :upload_handlers:
@@ -82,7 +82,7 @@ def __init__(
             The encoding with which to treat the incoming data.
         """
         # Content-Type should contain multipart and the boundary information.
-        content_type = meta.get("CONTENT_TYPE", "")
+        content_type = environ.get("CONTENT_TYPE", "")
         if not content_type.startswith("multipart/"):
             raise MultiPartParserError(f"Invalid Content-Type: {content_type}")
 
@@ -104,7 +104,7 @@ def __init__(
         # Content-Length should contain the length of the body we are about
         # to receive.
         try:
-            content_length = int(meta.get("CONTENT_LENGTH", 0))
+            content_length = int(environ.get("CONTENT_LENGTH", 0))
         except (ValueError, TypeError):
             content_length = 0
 
@@ -120,7 +120,7 @@ def __init__(
         possible_sizes = [x.chunk_size for x in upload_handlers if x.chunk_size]
         self._chunk_size = min([2**31 - 4] + possible_sizes)
 
-        self._meta = meta
+        self._environ = environ
         self._encoding = encoding or settings.DEFAULT_CHARSET
         self._content_length = content_length
         self._upload_handlers = upload_handlers
@@ -163,7 +163,7 @@ def _parse(self) -> tuple[Any, MultiValueDict]:
         for handler in handlers:
             result = handler.handle_raw_input(
                 self._input_data,
-                self._meta,
+                self._environ,
                 self._content_length,
                 self._boundary,
                 encoding,

plain/plain/http/request.py

@@ -65,7 +65,7 @@ class Request:
     content_params: dict[str, str] | None
     query_params: QueryDict
     cookies: dict[str, str]
-    meta: dict[str, Any]
+    environ: dict[str, Any]
     path: str
     path_info: str
     unique_id: str
@@ -103,7 +103,7 @@ def __deepcopy__(self, memo: dict[int, Any]) -> Request:
 
     @cached_property
     def headers(self) -> RequestHeaders:
-        return RequestHeaders(self.meta)
+        return RequestHeaders(self.environ)
 
     @cached_property
     def csp_nonce(self) -> str:
@@ -157,13 +157,15 @@ def host(self) -> str:
         property can safely return the host without any validation.
         """
         # We try three options, in order of decreasing preference.
-        if settings.HTTP_X_FORWARDED_HOST and ("HTTP_X_FORWARDED_HOST" in self.meta):
-            host = self.meta["HTTP_X_FORWARDED_HOST"]
-        elif "HTTP_HOST" in self.meta:
-            host = self.meta["HTTP_HOST"]
+        if settings.HTTP_X_FORWARDED_HOST and (
+            xff_host := self.headers.get("X-Forwarded-Host")
+        ):
+            host = xff_host
+        elif http_host := self.headers.get("Host"):
+            host = http_host
         else:
             # Reconstruct the host using the algorithm from PEP 333.
-            host = self.meta["SERVER_NAME"]
+            host = self.environ["SERVER_NAME"]
             server_port = self.port
             if server_port != ("443" if self.is_https() else "80"):
                 host = f"{host}:{server_port}"
@@ -172,10 +174,12 @@ def host(self) -> str:
     @cached_property
     def port(self) -> str:
         """Return the port number for the request as a string."""
-        if settings.HTTP_X_FORWARDED_PORT and "HTTP_X_FORWARDED_PORT" in self.meta:
-            port = self.meta["HTTP_X_FORWARDED_PORT"]
+        if settings.HTTP_X_FORWARDED_PORT and (
+            xff_port := self.headers.get("X-Forwarded-Port")
+        ):
+            port = xff_port
         else:
-            port = self.meta["SERVER_PORT"]
+            port = self.environ["SERVER_PORT"]
         return str(port)
 
     @cached_property
@@ -191,7 +195,12 @@ def client_ip(self) -> str:
         if settings.HTTP_X_FORWARDED_FOR:
             if xff := self.headers.get("X-Forwarded-For"):
                 return xff.split(",")[0].strip()
-        return self.meta["REMOTE_ADDR"]
+        return self.environ["REMOTE_ADDR"]
+
+    @property
+    def query_string(self) -> str:
+        """Return the raw query string from the request URL."""
+        return self.environ.get("QUERY_STRING", "")
 
     def get_full_path(self, force_append_slash: bool = False) -> str:
         """
@@ -219,11 +228,10 @@ def escape_uri_path(path: str) -> str:
             # the entire path, not a path segment.
             return quote(path, safe="/:@&+$,-_.!~*'()")
 
-        query_string = self.meta.get("QUERY_STRING", "")
         return "{}{}{}".format(
             escape_uri_path(self.path),
             "/" if force_append_slash and not self.path.endswith("/") else "",
-            ("?" + (iri_to_uri(query_string) or "")) if query_string else "",
+            ("?" + (iri_to_uri(self.query_string) or "")) if self.query_string else "",
         )
 
     def build_absolute_uri(self, location: str | None = None) -> str:
@@ -306,7 +314,7 @@ def body(self) -> bytes:
             # Limit the maximum request data size that will be handled in-memory.
             if (
                 settings.DATA_UPLOAD_MAX_MEMORY_SIZE is not None
-                and int(self.meta.get("CONTENT_LENGTH") or 0)
+                and int(self.environ.get("CONTENT_LENGTH") or 0)
                 > settings.DATA_UPLOAD_MAX_MEMORY_SIZE
             ):
                 raise RequestDataTooBig(
@@ -323,10 +331,12 @@ def body(self) -> bytes:
         return self._body
 
     def _parse_file_upload(
-        self, meta: dict[str, Any], post_data: IO[bytes]
+        self, environ: dict[str, Any], post_data: IO[bytes]
     ) -> tuple[Any, MultiValueDict]:
         """Return a tuple of (data QueryDict, files MultiValueDict)."""
-        parser = MultiPartParser(meta, post_data, self.upload_handlers, self.encoding)
+        parser = MultiPartParser(
+            environ, post_data, self.upload_handlers, self.encoding
+        )
         return parser.parse()
 
     @cached_property
@@ -341,7 +351,7 @@ def _multipart_data(self) -> tuple[QueryDict, MultiValueDict]:
             data = BytesIO(self._body)
         else:
             data = self
-        return self._parse_file_upload(self.meta, data)
+        return self._parse_file_upload(self.environ, data)
 
     @cached_property
     def json_data(self) -> dict[str, Any]:

plain/plain/internal/files/uploadhandler.py

@@ -97,7 +97,7 @@ def __init__(self, request: Request | None = None) -> None:
     def handle_raw_input(
         self,
         input_data: Any,
-        meta: dict[str, Any],
+        environ: dict[str, Any],
         content_length: int,
         boundary: bytes,
         encoding: str | None = None,
@@ -109,8 +109,8 @@ def handle_raw_input(
 
             :input_data:
                 An object that supports reading via .read().
-            :meta:
-                ``request.meta``.
+            :environ:
+                ``request.environ``.
             :content_length:
                 The (integer) value of the Content-Length header from the
                 client.
@@ -219,7 +219,7 @@ class MemoryFileUploadHandler(FileUploadHandler):
     def handle_raw_input(
         self,
         input_data: Any,
-        meta: dict[str, Any],
+        environ: dict[str, Any],
         content_length: int,
         boundary: bytes,
         encoding: str | None = None,

plain/plain/internal/handlers/base.py

@@ -89,8 +89,8 @@ def get_response(self, request: Request) -> ResponseBase:
             pass
 
         # Add query string if present
-        if query_string := request.meta.get("QUERY_STRING"):
-            span_attributes[url_attributes.URL_QUERY] = query_string
+        if request.query_string:
+            span_attributes[url_attributes.URL_QUERY] = request.query_string
 
         span_context = baggage.set_baggage("http.request.cookies", request.cookies)
         span_context = baggage.set_baggage(

plain/plain/internal/handlers/wsgi.py

@@ -82,9 +82,9 @@ def __init__(self, environ: dict[str, Any]) -> None:
         self.path = "{}/{}".format(
             script_name.rstrip("/"), path_info.replace("/", "", 1)
         )
-        self.meta = environ
-        self.meta["PATH_INFO"] = path_info
-        self.meta["SCRIPT_NAME"] = script_name
+        self.environ = environ
+        self.environ["PATH_INFO"] = path_info
+        self.environ["SCRIPT_NAME"] = script_name
         self.method = environ["REQUEST_METHOD"].upper()
 
         # Set content_type, content_params, and encoding
@@ -109,8 +109,8 @@ def __init__(self, environ: dict[str, Any]) -> None:
     def __getstate__(self) -> dict[str, Any]:
         state = super().__getstate__()
         for attr in frozenset(["wsgi.errors", "wsgi.input"]):
-            if attr in state["meta"]:
-                del state["meta"][attr]
+            if attr in state["environ"]:
+                del state["environ"][attr]
         return state
 
     def _get_scheme(self) -> str:

plain/plain/views/redirect.py

@@ -42,9 +42,8 @@ def get_redirect_url(self) -> str:
         else:
             raise ValueError("RedirectView requires either url or url_name to be set")
 
-        args = self.request.meta.get("QUERY_STRING", "")
-        if args and self.preserve_query_params:
-            url = f"{url}?{args}"
+        if self.preserve_query_params and self.request.query_string:
+            url = f"{url}?{self.request.query_string}"
         return url
 
     def get(self) -> ResponseRedirect: