fix: end multipart responses with the closing boundary (#592)

## What

`multipart/mixed` responses now end with the closing boundary line that
the MIME format requires.

```
Before (end of response):   After (end of response):
<last part data>            <last part data>
                            --3f9c...--
```

## Why

Without the closing line, strict multipart parsers report the response
as incomplete. If processing fails partway through, the closing line is
still left out, so clients can tell a cut-off response from a complete
one.

## Validation

Tests parse the response with Python's `email` parser (no defects) for
one part, several parts, and no parts, and cover an interrupted stream.
They fail on `main`. Adds a CHANGELOG entry and bumps the version to
0.1.15.

Refreshed against main after #590 and #591 merged. Targeted API tests:
43 passed; response compatibility tests: 4 passed. Changed-source lint
passed.

Author: CyMule

CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.1.15
+
+### Fixes
+
+- **Terminate multipart responses with the closing boundary**: `multipart/mixed` responses ended after the last part without the closing `--boundary--` delimiter, so strict MIME parsers reported an incomplete message. The closing delimiter is now sent when the stream completes. A stream that fails partway still ends without it.
+
 ## 0.1.14
 
 ### Fixes

prepline_general/api/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.14"  # pragma: no cover
+__version__ = "0.1.15"  # pragma: no cover

prepline_general/api/general.py

@@ -31,6 +31,7 @@
 from starlette.datastructures import Headers
 from starlette.types import Send
 
+from prepline_general.api import __version__ as api_version
 from prepline_general.api.filetypes import get_validated_mimetype
 from prepline_general.api.models.form_params import GeneralFormParams
 from unstructured.documents.elements import Element
@@ -41,19 +42,18 @@
     elements_from_json,
 )
 from unstructured_inference.models.base import UnknownModelException
-from prepline_general.api import __version__ as api_version
 
 app = FastAPI()
 router = APIRouter()
 
 
 def is_compatible_response_type(media_type: str, response_type: type) -> bool:
     """True when `response_type` can be converted to `media_type` for HTTP Response."""
-    return (
-        False
-        if media_type == "application/json" and response_type not in [dict, list]
-        else False if media_type == "text/csv" and response_type != str else True
-    )
+    if media_type == "application/json":
+        return response_type in [dict, list]
+    if media_type == "text/csv":
+        return response_type is str
+    return True
 
 
 logger = logging.getLogger("unstructured_api")
@@ -606,7 +606,13 @@ async def stream_response(self, send: Send) -> None:
                 {"type": "http.response.body", "body": self.build_part(chunk), "more_body": True}
             )
 
-        await send({"type": "http.response.body", "body": b"", "more_body": False})
+        await send(
+            {
+                "type": "http.response.body",
+                "body": self.boundary + b"--" + self.CRLF,
+                "more_body": False,
+            }
+        )
 
 
 def ungz_file(file: UploadFile, gz_uncompressed_content_type: Optional[str] = None) -> UploadFile:
@@ -651,7 +657,7 @@ def general_partition(
     # cannot use annotated type here because of a bug described here:
     # https://github.com/tiangolo/fastapi/discussions/10280
     # The openapi metadata must be added separately in openapi.py file.
-    # TODO: Check if the bug is fixed and change the declaration to use Annotated[List[UploadFile], File(...)]
+    # TODO: Check whether FastAPI supports Annotated[List[UploadFile], File(...)].
     # For new parameters - add them in models/form_params.py
     files: List[UploadFile],
     form_params: GeneralFormParams = Depends(GeneralFormParams.as_form),

test_general/api/test_multipart_response.py

@@ -0,0 +1,64 @@
+import asyncio
+from email import policy
+from email.parser import BytesParser
+
+import pytest
+
+from prepline_general.api.general import MultipartMixedResponse
+
+
+async def collect_response(response):
+    messages = []
+
+    async def send(message):
+        messages.append(message)
+
+    await response.stream_response(send)
+    return messages
+
+
+@pytest.mark.parametrize("parts", [["one"], ["one", "two"]])
+def test_normal_multipart_response_closes_boundary_and_preserves_parts(parts):
+    response = MultipartMixedResponse(iter(parts), content_type="text/plain")
+    messages = asyncio.run(collect_response(response))
+    body = b"".join(message.get("body", b"") for message in messages)
+    content_type = response.headers["content-type"].encode()
+    parsed = BytesParser(policy=policy.default).parsebytes(
+        b"Content-Type: " + content_type + b"\r\nMIME-Version: 1.0\r\n\r\n" + body
+    )
+
+    assert parsed.defects == []
+    assert [part.get_payload(decode=True).decode() for part in parsed.iter_parts()] == parts
+    assert messages[-1] == {
+        "type": "http.response.body",
+        "body": response.boundary + b"--\r\n",
+        "more_body": False,
+    }
+    assert all(message["more_body"] for message in messages[1:-1])
+
+
+def test_empty_iterator_emits_terminal_boundary():
+    response = MultipartMixedResponse(iter([]))
+    messages = asyncio.run(collect_response(response))
+
+    assert messages[-1]["body"] == response.boundary + b"--\r\n"
+    assert messages[-1]["more_body"] is False
+
+
+def test_interrupted_stream_does_not_emit_terminal_boundary():
+    messages = []
+
+    async def failing_parts():
+        yield "one"
+        raise RuntimeError("partition failed")
+
+    async def send(message):
+        messages.append(message)
+
+    response = MultipartMixedResponse(failing_parts(), content_type="text/plain")
+    with pytest.raises(RuntimeError, match="partition failed"):
+        asyncio.run(response.stream_response(send))
+
+    assert len(messages) == 2
+    assert messages[-1]["more_body"] is True
+    assert not messages[-1]["body"].endswith(response.boundary + b"--\r\n")