fix: Read duck-typed file-like values and encode KVS records off the event loop

Author: vdusek

src/apify_client/_resource_clients/key_value_store.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import re
 from contextlib import asynccontextmanager, contextmanager
 from http import HTTPStatus
@@ -801,7 +802,11 @@ async def set_record(
             content_type: The content type of the saved value.
             timeout: Timeout for the API HTTP request.
         """
-        value, content_type = encode_key_value_store_record_value(value, content_type=content_type)
+        # Encoding reads file-like values and may serialize large payloads, which is blocking; offload it to a
+        # worker thread so it does not stall the event loop (mirrors the transport's own body-prep offload).
+        value, content_type = await asyncio.to_thread(
+            encode_key_value_store_record_value, value, content_type=content_type
+        )
 
         headers = {'content-type': content_type}
 

src/apify_client/_utils/encoding.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import io
 import json
 from base64 import b64encode
 from functools import cache
@@ -23,9 +22,12 @@ def encode_key_value_store_record_value(value: Any, *, content_type: str | None
         A tuple of (encoded_value, content_type).
     """
     # Read file-like values into memory; the underlying HTTP transport only accepts bytes-like bodies,
-    # so a file object would otherwise reach it unread and raise a raw `TypeError`.
-    if isinstance(value, io.IOBase):
-        value = value.read()
+    # so a file object would otherwise reach it unread and raise a raw `TypeError`. Detect them by a
+    # callable `read` rather than `io.IOBase` so duck-typed file-likes (upload wrappers, raw streams)
+    # are read too, instead of falling through to JSON serialization.
+    read = getattr(value, 'read', None)
+    if callable(read):
+        value = read()
 
     if not content_type:
         if isinstance(value, (bytes, bytearray)):

tests/unit/test_key_value_store.py

@@ -58,3 +58,23 @@ def capture_request(request: Request) -> Response:
     assert len(captured_requests) == 1
     assert _decode_body(captured_requests[0]) == b'buffer data'
     assert captured_requests[0].headers['content-type'] == 'application/octet-stream'
+
+
+def test_set_record_reads_stringio_value_sync(httpserver: HTTPServer) -> None:
+    """Regression test: a text file-like value is read and uploaded as text/plain through the HTTP stack."""
+    captured_requests: list[Request] = []
+
+    def capture_request(request: Request) -> Response:
+        captured_requests.append(request)
+        return Response(status=201)
+
+    httpserver.expect_request(_RECORD_PATH, method='PUT').respond_with_handler(capture_request)
+
+    api_url = httpserver.url_for('/').removesuffix('/')
+    client = ApifyClient(token='test_token', api_url=api_url)
+
+    client.key_value_store(_MOCKED_KVS_ID).set_record('f', io.StringIO('buffer data'))
+
+    assert len(captured_requests) == 1
+    assert _decode_body(captured_requests[0]) == b'buffer data'
+    assert captured_requests[0].headers['content-type'] == 'text/plain; charset=utf-8'

tests/unit/test_utils.py

@@ -264,6 +264,18 @@ def test_encode_key_value_store_record_value_stringio() -> None:
     assert content_type == 'text/plain; charset=utf-8'
 
 
+def test_encode_key_value_store_record_value_duck_typed_file_like() -> None:
+    """Test that a duck-typed file-like value (a callable `read`, not an `io.IOBase`) is read into bytes."""
+
+    class _Reader:
+        def read(self) -> bytes:
+            return b'buffer data'
+
+    value, content_type = encode_key_value_store_record_value(_Reader())
+    assert value == b'buffer data'
+    assert content_type == 'application/octet-stream'
+
+
 def test_response_to_dict() -> None:
     """Test parsing response as dictionary."""
     mock_response = Mock()