fix: Harden MultipartStream size handling and test non-seekable uploads

- Clamp the part size to zero for streams positioned past their end.
- Read the end position with tell() so streams whose seek() returns None work.
- Fail immediately with BoxSDKError when a part stream ends before its
  declared size, instead of retrying a request that can't succeed.
- List urllib3 in install_requires, since it is now imported directly.
- Add an integration test uploading a file and a file version from a
  non-seekable stream, which is sent with chunked transfer encoding.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: congminh1254

box_sdk_gen/networking/box_network_client.py

@@ -293,6 +293,13 @@ def _make_request(self, request: APIRequest) -> APIResponse:
                 timeout=timeout,
             )
         except RequestException as request_exc:
+            if (
+                isinstance(request.data, MultipartStream)
+                and request.data.size_error is not None
+            ):
+                raise BoxSDKError(
+                    message=str(request.data.size_error), error=request_exc
+                ) from request_exc
             raised_exception = request_exc
             network_response = None
 

box_sdk_gen/networking/multipart_stream.py

@@ -37,6 +37,8 @@ def __init__(self, fields: List[MultipartField]):
         self._segments.append(f'--{self.boundary}--\r\n'.encode('utf-8'))
         self._index = 0
         self._offset = 0
+        # set when a part stream ends before its declared size; retrying won't help
+        self.size_error: Optional[IOError] = None
         # bytes still to send per stream segment, None when the size is unknown
         self._remaining: List[Optional[int]] = [
             None if isinstance(segment, bytes) else self._stream_size(segment)
@@ -52,10 +54,12 @@ def _stream_size(stream: ByteStream) -> Optional[int]:
             if not stream.seekable():
                 return None
             position = stream.tell()
-            size = stream.seek(0, SEEK_END) - position
+            stream.seek(0, SEEK_END)
+            end = stream.tell()
             stream.seek(position)
-            return size
-        except (OSError, AttributeError):
+            # a stream positioned past its end has nothing left to send
+            return max(0, end - position)
+        except (OSError, AttributeError, TypeError):
             return None
 
     def _compute_length(self) -> Optional[int]:
@@ -93,9 +97,10 @@ def read(self, size: Optional[int] = -1) -> bytes:
                 )
                 if not chunk:
                     if remaining is not None:
-                        raise IOError(
+                        self.size_error = IOError(
                             f'Multipart stream ended {remaining} bytes before its declared size'
                         )
+                        raise self.size_error
                     self._index += 1
                     continue
                 if remaining is not None:

setup.py

@@ -6,7 +6,7 @@
 
 
 def main():
-    install_requires = ['requests']
+    install_requires = ['requests', 'urllib3']
     tests_require = [
         'pytest',
         'pytest-timeout',

test/box_network_client.py

@@ -1459,3 +1459,43 @@ def test_multipart_stream_sends_declared_size_when_stream_grows():
 
     assert len(body) == multipart_stream.len
     assert b"EXTRA" not in body
+
+
+def test_multipart_upload_short_stream_fails_without_retry(multipart_server):
+    url, _, _ = multipart_server
+
+    class Truncated(BytesIO):
+        def read(self, size=-1):
+            return super().read(max(0, min(size, 5 - self.tell())))
+
+    with patch("time.sleep") as sleep:
+        with pytest.raises(BoxSDKError, match="ended 5 bytes before its declared size"):
+            BoxNetworkClient().fetch(_upload_options(url, Truncated(b"0123456789")))
+
+    sleep.assert_not_called()
+
+
+def test_multipart_stream_positioned_past_end_sends_empty_part():
+    stream = BytesIO(b"0123456789")
+    stream.seek(20)
+    multipart_stream = MultipartStream([("file", "f", stream, None)])
+
+    body = multipart_stream.read()
+
+    assert len(body) == multipart_stream.len
+    assert body.count(b"\r\n\r\n\r\n") == 1
+
+
+def test_multipart_stream_handles_seek_returning_none():
+    class LegacySeek(BytesIO):
+        def seek(self, *args):
+            super().seek(*args)
+
+    stream = LegacySeek(b"0123456789")
+    stream.read(2)
+    multipart_stream = MultipartStream([("file", "f", stream, None)])
+
+    body = multipart_stream.read()
+
+    assert len(body) == multipart_stream.len
+    assert b"\r\n\r\n23456789\r\n" in body

test/multipart_uploads.py

@@ -0,0 +1,64 @@
+from io import BytesIO, RawIOBase
+
+from box_sdk_gen.client import BoxClient
+from box_sdk_gen.internal.utils import (
+    generate_byte_buffer,
+    get_uuid,
+    read_byte_stream,
+)
+from box_sdk_gen.managers.uploads import (
+    UploadFileAttributes,
+    UploadFileAttributesParentField,
+    UploadFileVersionAttributes,
+)
+from box_sdk_gen.schemas.file_full import FileFull
+
+from test.commons import get_default_client
+
+client: BoxClient = get_default_client()
+
+
+class NonSeekableStream(RawIOBase):
+    def __init__(self, content: bytes):
+        self._content = BytesIO(content)
+
+    def readable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return False
+
+    def readinto(self, buffer) -> int:
+        chunk = self._content.read(len(buffer))
+        buffer[: len(chunk)] = chunk
+        return len(chunk)
+
+
+def testUploadFileAndFileVersionFromNonSeekableStream():
+    content: bytes = generate_byte_buffer(5 * 1024 * 1024)
+    new_file_name: str = get_uuid()
+    uploaded_file: FileFull = client.uploads.upload_file(
+        UploadFileAttributes(
+            name=new_file_name, parent=UploadFileAttributesParentField(id='0')
+        ),
+        NonSeekableStream(content),
+    ).entries[0]
+    try:
+        assert uploaded_file.name == new_file_name
+        assert uploaded_file.size == len(content)
+        assert read_byte_stream(client.downloads.download_file(uploaded_file.id)) == (
+            content
+        )
+
+        new_content: bytes = generate_byte_buffer(1024 * 1024)
+        new_file_version: FileFull = client.uploads.upload_file_version(
+            uploaded_file.id,
+            UploadFileVersionAttributes(name=get_uuid()),
+            NonSeekableStream(new_content),
+        ).entries[0]
+        assert new_file_version.size == len(new_content)
+        assert read_byte_stream(client.downloads.download_file(uploaded_file.id)) == (
+            new_content
+        )
+    finally:
+        client.files.delete_file_by_id(uploaded_file.id)