fix(etl-uvicorn): preserve a None file_data instead of dumping it

Review found that `run_job_with_body` converted `file_data` from its dict
form unconditionally, so a plugin declaring `file_data` optional raised

    AttributeError: 'NoneType' object has no attribute 'model_dump'

before `wrap_fn` could run -- surfacing as a 500 rather than the normal
response the signature promises.

This predates the optional-body change: it was already reachable on main
via `POST {}`, since an omitted field is None whether the body is absent
or merely partial. Defaulting the body widens the same hole to bodyless
requests, so fix it here rather than leaving a 500 behind the contract
this branch is establishing.

Pass None through untouched and convert only a real value. A plugin with a
required `file_data` is unaffected: validation rejects the request before
this line, so the conversion still always runs when the field is declared
mandatory.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: badGarnet

CHANGELOG.md

@@ -8,6 +8,11 @@
   An absent body now resolves each field to its own default, which is what the signature already
   promised. Plugins with at least one required field are unchanged: a missing `file_data` still
   fails validation rather than arriving as `None`.
+* **An optional `file_data` no longer 500s when absent.** The wrapper converted `file_data` from its
+  dict form unconditionally, so a plugin declaring it optional hit
+  `AttributeError: 'NoneType' object has no attribute 'model_dump'` on any body that omitted it —
+  previously reachable via `POST {}`, and via a bodyless request once the change above landed. `None`
+  is now passed through untouched and only a real value is converted.
 
 ## 0.0.44
 

test/api/test_api.py

@@ -539,6 +539,41 @@ def test_required_param_still_rejects_an_absent_body():
     assert client.post("/invoke", json={"element_dicts": "x"}).status_code == 200
 
 
+class _FileDataEcho(BaseModel):
+    identifier: Optional[str] = None
+
+
+def _optional_file_data(
+    file_data: Optional[FileData] = None, invocation_context: Optional[dict] = None
+) -> _FileDataEcho:
+    return _FileDataEcho(identifier=None if file_data is None else file_data.identifier)
+
+
+@pytest.mark.parametrize("body", [None, {}])
+def test_optional_file_data_is_preserved_as_none(body):
+    # `file_data` is converted from its dict form for the wrapped function, but it can legitimately
+    # be absent. Calling `.model_dump()` on None raised before `wrap_fn` ran, turning the
+    # optional-body contract into a 500 rather than a normal response.
+    client = TestClient(wrap_in_fastapi(func=_optional_file_data, plugin_id="mock_plugin"))
+
+    kwargs = {} if body is None else {"json": body}
+    resp = client.post("/invoke", **kwargs)
+
+    assert resp.status_code == 200
+    invoke_response = InvokeResponse.model_validate(resp.json())
+    invoke_response.generic_validation()
+    assert invoke_response.output == {"identifier": None}
+
+
+def test_optional_file_data_is_still_converted_when_supplied():
+    client = TestClient(wrap_in_fastapi(func=_optional_file_data, plugin_id="mock_plugin"))
+
+    resp = client.post("/invoke", json={"file_data": mock_file_data[0].model_dump()})
+
+    assert resp.status_code == 200
+    assert InvokeResponse.model_validate(resp.json()).output == {"identifier": "mock file data"}
+
+
 def test_no_param_plugin_still_accepts_a_bodyless_post():
     client = TestClient(wrap_in_fastapi(func=_no_params, plugin_id="mock_plugin"))
 

unstructured_platform_plugins/etl_uvicorn/api_generator.py

@@ -258,9 +258,13 @@ async def run_job_with_body(request: BaseModel) -> ResponseType:
         log_func_and_body(func=func, body=request.json())
         # Create dictionary from pydantic model while preserving underlying types
         request_dict = {f: getattr(request, f) for f in request.model_fields}
-        # Make sure nested classes get instantiated correctly
-        if "file_data" in request_dict:
-            request_dict["file_data"] = file_data_from_dict(request_dict["file_data"].model_dump())
+        # Make sure nested classes get instantiated correctly. `file_data` can legitimately be None
+        # -- a plugin may declare it optional, and then an absent or partial body leaves it unset --
+        # so convert only a real value. Calling `.model_dump()` on None would raise before `wrap_fn`
+        # runs, turning the optional-body contract into a 500.
+        file_data = request_dict.get("file_data")
+        if file_data is not None:
+            request_dict["file_data"] = file_data_from_dict(file_data.model_dump())
         map_inputs(func=func, raw_inputs=request_dict)
         if logger.level == LOG_LEVELS.get("trace", logging.NOTSET):
             logger.log(level=logger.level, msg=f"passing inputs to function: {request_dict}")