Add request.content_length, simplify MultiPartParser to use request only

Author: davegaeddert

plain/plain/http/multipartparser.py

@@ -28,7 +28,7 @@
 from plain.utils.regex_helper import _lazy_re_compile
 
 if TYPE_CHECKING:
-    from plain.internal.files.uploadhandler import FileUploadHandler
+    from plain.http.request import Request
 
 __all__ = ("MultiPartParser", "MultiPartParserError", "InputStreamExhausted")
 
@@ -61,28 +61,15 @@ class MultiPartParser:
 
     boundary_re = _lazy_re_compile(r"[ -~]{0,200}[!-~]")
 
-    def __init__(
-        self,
-        environ: dict[str, Any],
-        input_data: Any,
-        upload_handlers: list[FileUploadHandler],
-        encoding: str | None = None,
-    ):
+    def __init__(self, request: Request):
         """
         Initialize the MultiPartParser object.
 
-        :environ:
-            The WSGI environ dictionary from the request.
-        :input_data:
-            The raw post data, as a file-like object.
-        :upload_handlers:
-            A list of UploadHandler instances that perform operations on the
-            uploaded data.
-        :encoding:
-            The encoding with which to treat the incoming data.
+        :request:
+            The HTTP request object (used for headers and as the input stream).
         """
         # Content-Type should contain multipart and the boundary information.
-        content_type = environ.get("CONTENT_TYPE", "")
+        content_type = request.content_type or ""
         if not content_type.startswith("multipart/"):
             raise MultiPartParserError(f"Invalid Content-Type: {content_type}")
 
@@ -93,37 +80,30 @@ def __init__(
                 f"Invalid non-ASCII Content-Type in multipart: {force_str(content_type)}"
             )
 
-        # Parse the header to get the boundary to split the parts.
-        _, opts = parse_header_parameters(content_type)
-        boundary = opts.get("boundary")
+        # Get the boundary from parsed content type parameters.
+        content_params = request.content_params or {}
+        boundary = content_params.get("boundary")
         if not boundary or not self.boundary_re.fullmatch(boundary):
             raise MultiPartParserError(
                 f"Invalid boundary in multipart: {force_str(boundary)}"
             )
 
-        # Content-Length should contain the length of the body we are about
-        # to receive.
-        try:
-            content_length = int(environ.get("CONTENT_LENGTH", 0))
-        except (ValueError, TypeError):
-            content_length = 0
-
+        content_length = request.content_length
         if content_length < 0:
             # This means we shouldn't continue...raise an error.
             raise MultiPartParserError(f"Invalid content length: {content_length!r}")
 
         self._boundary = boundary.encode("ascii")
-        self._input_data = input_data
+        self._request = request
 
         # For compatibility with low-level network APIs (with 32-bit integers),
         # the chunk size should be < 2^31, but still divisible by 4.
-        possible_sizes = [x.chunk_size for x in upload_handlers if x.chunk_size]
+        possible_sizes = [x.chunk_size for x in request.upload_handlers if x.chunk_size]
         self._chunk_size = min([2**31 - 4] + possible_sizes)
 
-        self._environ = environ
-        self._encoding = encoding or settings.DEFAULT_CHARSET
+        self._encoding = request.encoding or settings.DEFAULT_CHARSET
         self._content_length = content_length
-        self._upload_handlers = upload_handlers
+        self._upload_handlers = request.upload_handlers
 
     def parse(self) -> tuple[Any, MultiValueDict]:
         # Call the actual parse routine and close all open files in case of
@@ -162,9 +142,7 @@ def _parse(self) -> tuple[Any, MultiValueDict]:
         # This allows overriding everything if need be.
         for handler in handlers:
             result = handler.handle_raw_input(
-                self._input_data,
-                self._environ,
-                self._content_length,
+                self._request,
                 self._boundary,
                 encoding,
             )
@@ -177,7 +155,7 @@ def _parse(self) -> tuple[Any, MultiValueDict]:
         self._files = MultiValueDict()
 
         # Instantiate the parser and stream:
-        stream = LazyStream(ChunkIter(self._input_data, self._chunk_size))
+        stream = LazyStream(ChunkIter(self._request, self._chunk_size))
 
         # Whether or not to signal a file-completion at the beginning of the loop.
         old_field_name = None
@@ -366,13 +344,13 @@ def _parse(self) -> tuple[Any, MultiValueDict]:
         except StopUpload as e:
             self._close_files()
             if not e.connection_reset:
-                exhaust(self._input_data)
+                exhaust(self._request)
         else:
             if not uploaded_file:
                 for handler in handlers:
                     handler.upload_interrupted()
             # Make sure that the request data is all fed
-            exhaust(self._input_data)
+            exhaust(self._request)
 
         # Signal that the upload has completed.
         # any() shortcircuits if a handler's upload_complete() returns a value.

plain/plain/http/request.py

@@ -8,7 +8,7 @@
 from functools import cached_property
 from io import BytesIO
 from itertools import chain
-from typing import IO, TYPE_CHECKING, Any, TypeVar, overload
+from typing import TYPE_CHECKING, Any, TypeVar, overload
 from urllib.parse import parse_qsl, quote, urlencode, urljoin, urlsplit
 
 if TYPE_CHECKING:
@@ -202,6 +202,14 @@ def query_string(self) -> str:
         """Return the raw query string from the request URL."""
         return self.environ.get("QUERY_STRING", "")
 
+    @property
+    def content_length(self) -> int:
+        """Return the Content-Length header value, or 0 if not provided."""
+        try:
+            return int(self.environ.get("CONTENT_LENGTH") or 0)
+        except (ValueError, TypeError):
+            return 0
+
     def get_full_path(self, force_append_slash: bool = False) -> str:
         """
         Return the full path for the request, including query string.
@@ -314,8 +322,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.environ.get("CONTENT_LENGTH") or 0)
-                > settings.DATA_UPLOAD_MAX_MEMORY_SIZE
+                and self.content_length > settings.DATA_UPLOAD_MAX_MEMORY_SIZE
             ):
                 raise RequestDataTooBig(
                     "Request body exceeded settings.DATA_UPLOAD_MAX_MEMORY_SIZE."
@@ -330,28 +337,14 @@ def body(self) -> bytes:
             self._stream = BytesIO(self._body)
         return self._body
 
-    def _parse_file_upload(
-        self, environ: dict[str, Any], post_data: IO[bytes]
-    ) -> tuple[Any, MultiValueDict]:
-        """Return a tuple of (data QueryDict, files MultiValueDict)."""
-        parser = MultiPartParser(
-            environ, post_data, self.upload_handlers, self.encoding
-        )
-        return parser.parse()
-
     @cached_property
     def _multipart_data(self) -> tuple[QueryDict, MultiValueDict]:
         """Parse multipart/form-data. Used internally by form_data and files properties.
 
         Raises MultiPartParserError or TooManyFilesSent for malformed uploads,
         which are handled by response_for_exception() as 400 errors.
         """
-        if hasattr(self, "_body"):
-            # Use already read data
-            data = BytesIO(self._body)
-        else:
-            data = self
-        return self._parse_file_upload(self.environ, data)
+        return MultiPartParser(self).parse()
 
     @cached_property
     def json_data(self) -> dict[str, Any]:

plain/plain/internal/files/uploadhandler.py

@@ -86,7 +86,7 @@ class FileUploadHandler(ABC):
 
     chunk_size = 64 * 2**10  # : The default chunk size is 64 KB.
 
-    def __init__(self, request: Request | None = None) -> None:
+    def __init__(self, request: Request) -> None:
         self.file_name = None
         self.content_type = None
         self.content_length = None
@@ -97,8 +97,6 @@ def __init__(self, request: Request | None = None) -> None:
     def handle_raw_input(
         self,
         input_data: Any,
-        environ: dict[str, Any],
-        content_length: int,
         boundary: bytes,
         encoding: str | None = None,
     ) -> None:
@@ -109,13 +107,13 @@ def handle_raw_input(
 
             :input_data:
                 An object that supports reading via .read().
-            :environ:
-                ``request.environ``.
-            :content_length:
-                The (integer) value of the Content-Length header from the
-                client.
-            :boundary: The boundary from the Content-Type header. Be sure to
+            :boundary:
+                The boundary from the Content-Type header. Be sure to
                 prepend two '--'.
+            :encoding:
+                The encoding of the request data.
+
+        Note: Access self.request for content_length, environ, or other request data.
         """
         pass
 
@@ -219,8 +217,6 @@ class MemoryFileUploadHandler(FileUploadHandler):
     def handle_raw_input(
         self,
         input_data: Any,
-        environ: dict[str, Any],
-        content_length: int,
         boundary: bytes,
         encoding: str | None = None,
     ) -> None:
@@ -230,7 +226,9 @@ def handle_raw_input(
         """
         # Check the content-length header to see if we should
         # If the post is too large, we cannot use the Memory handler.
-        self.activated = content_length <= settings.FILE_UPLOAD_MAX_MEMORY_SIZE
+        self.activated = (
+            self.request.content_length <= settings.FILE_UPLOAD_MAX_MEMORY_SIZE
+        )
 
     def new_file(self, *args: Any, **kwargs: Any) -> None:
         super().new_file(*args, **kwargs)