riffsdk 0.4.0__tar.gz → 0.4.2__tar.gz

{riffsdk-0.4.0 → riffsdk-0.4.2}/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 <!-- version list -->
 
+## v0.4.2 (2026-06-11)
+
+### Bug Fixes
+
+- Resume flow bugfixes ([#11](https://github.com/databutton/riff-sdk-python/pull/11),
+  [`21eee3f`](https://github.com/databutton/riff-sdk-python/commit/21eee3fb8ac7b7148c34f06119b1d361c191c808))
+
+- Send correct content-type when uploading parts
+  ([#11](https://github.com/databutton/riff-sdk-python/pull/11),
+  [`21eee3f`](https://github.com/databutton/riff-sdk-python/commit/21eee3fb8ac7b7148c34f06119b1d361c191c808))
+
+### Chores
+
+- Use 3.11 in mise file ([#11](https://github.com/databutton/riff-sdk-python/pull/11),
+  [`21eee3f`](https://github.com/databutton/riff-sdk-python/commit/21eee3fb8ac7b7148c34f06119b1d361c191c808))
+
+### Testing
+
+- Assert content-type is persisted after resumed multipart upload
+  ([#11](https://github.com/databutton/riff-sdk-python/pull/11),
+  [`21eee3f`](https://github.com/databutton/riff-sdk-python/commit/21eee3fb8ac7b7148c34f06119b1d361c191c808))
+
+- Cover content-type propagation through resumable uploads
+  ([#11](https://github.com/databutton/riff-sdk-python/pull/11),
+  [`21eee3f`](https://github.com/databutton/riff-sdk-python/commit/21eee3fb8ac7b7148c34f06119b1d361c191c808))
+
+
+## v0.4.1 (2026-06-10)
+
+### Bug Fixes
+
+- Update integration test default base URL to include /riff-api
+  ([#10](https://github.com/databutton/riff-sdk-python/pull/10),
+  [`6a18180`](https://github.com/databutton/riff-sdk-python/commit/6a181808176fb964e2d898045713e62f42681f47))
+
+
 ## v0.4.0 (2026-06-10)
 
 ### Bug Fixes

{riffsdk-0.4.0 → riffsdk-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riffsdk
-Version: 0.4.0
+Version: 0.4.2
 Summary: Python SDK for the Riff Storage API
 License-File: LICENCE
 Requires-Python: >=3.11

{riffsdk-0.4.0 → riffsdk-0.4.2}/mise.toml

@@ -1,5 +1,5 @@
 [tools]
-python = "3.13"
+python = "3.11"
 uv = "latest"
 
 [tasks.test]

{riffsdk-0.4.0 → riffsdk-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "riffsdk"
-version = "0.4.0"
+version = "0.4.2"
 description = "Python SDK for the Riff Storage API"
 requires-python = ">=3.11"
 dependencies = ["httpx>=0.27", "pydantic>=2.6", "tenacity>=8.3"]

{riffsdk-0.4.0 → riffsdk-0.4.2}/src/riffsdk/storage/_async_client.py

@@ -370,6 +370,7 @@ class AsyncStorageClient:
             session_token=data["session_token"],
             session_expires_at=datetime.fromisoformat(data["session_expires_at"]),
             parts=parts,
+            content_type=content_type,
         )
 
     async def resume_upload(
@@ -399,6 +400,7 @@ class AsyncStorageClient:
             session_token=data["session_token"],
             session_expires_at=datetime.fromisoformat(data["session_expires_at"]),
             parts=parts,
+            content_type=data.get("content_type", "application/octet-stream"),
         )
 
     # --- Download ---

{riffsdk-0.4.0 → riffsdk-0.4.2}/src/riffsdk/storage/_client.py

@@ -370,6 +370,7 @@ class StorageClient:
             session_token=data["session_token"],
             session_expires_at=datetime.fromisoformat(data["session_expires_at"]),
             parts=parts,
+            content_type=content_type,
         )
 
     def resume_upload(self, upload_id: str, *, scope: Scope = None) -> ResumableUpload:
@@ -397,6 +398,7 @@ class StorageClient:
             session_token=data["session_token"],
             session_expires_at=datetime.fromisoformat(data["session_expires_at"]),
             parts=parts,
+            content_type=data.get("content_type", "application/octet-stream"),
         )
 
     # --- Download ---

{riffsdk-0.4.0 → riffsdk-0.4.2}/src/riffsdk/storage/_upload.py

@@ -26,6 +26,7 @@ class ResumableUpload:
         session_token: str,
         session_expires_at: datetime,
         parts: list[UploadPart],
+        content_type: str = "application/octet-stream",
     ) -> None:
         self._transport = transport
         self._sessions = sessions
@@ -36,6 +37,7 @@ class ResumableUpload:
         self.part_size = part_size
         self.expires_at = expires_at
         self.session_expires_at = session_expires_at
+        self.content_type = content_type
 
         self._session_token = session_token
         self._parts: dict[int, UploadPart] = {p.part_number: p for p in parts}
@@ -61,7 +63,7 @@ class ResumableUpload:
         resp = self._transport.request_raw_put(
             part.url,
             content=data,
-            headers={"Content-Type": "application/octet-stream"},
+            headers={"Content-Type": self.content_type},
         )
 
         etag = resp.headers.get("ETag", "")
@@ -134,6 +136,7 @@ class AsyncResumableUpload:
         session_token: str,
         session_expires_at: datetime,
         parts: list[UploadPart],
+        content_type: str = "application/octet-stream",
     ) -> None:
         self._transport = transport
         self._sessions = sessions
@@ -144,6 +147,7 @@ class AsyncResumableUpload:
         self.part_size = part_size
         self.expires_at = expires_at
         self.session_expires_at = session_expires_at
+        self.content_type = content_type
 
         self._session_token = session_token
         self._parts: dict[int, UploadPart] = {p.part_number: p for p in parts}
@@ -169,7 +173,7 @@ class AsyncResumableUpload:
         resp = await self._transport.request_raw_put(
             part.url,
             content=data,
-            headers={"Content-Type": "application/octet-stream"},
+            headers={"Content-Type": self.content_type},
         )
 
         etag = resp.headers.get("ETag", "")

{riffsdk-0.4.0 → riffsdk-0.4.2}/tests/test_async_client.py

@@ -874,3 +874,96 @@ class TestAsyncBeginUpload:
             _, kwargs = mock_req.call_args
             assert kwargs["json"]["key"] == "big.bin"
             assert kwargs["json"]["size"] == 2048
+
+    @pytest.mark.asyncio
+    async def test_begin_upload_threads_content_type(self):
+        client = _make_client()
+        resp = _mock_response(
+            {
+                "upload_id": "u-1",
+                "key": "doc.txt",
+                "part_count": 1,
+                "part_size": 1024,
+                "expires_at": "2024-01-01T02:00:00Z",
+                "session_token": "sess-tok",
+                "session_expires_at": "2024-01-01T01:00:00Z",
+                "parts": [
+                    {
+                        "part_number": 1,
+                        "byte_range_start": 0,
+                        "byte_range_end": 1023,
+                        "url": "https://signed.example.com/part1",
+                        "url_expires_at": "2024-01-01T01:00:00Z",
+                    },
+                ],
+            }
+        )
+        with patch.object(
+            client._transport, "request", new_callable=AsyncMock, return_value=resp
+        ):
+            upload = await client.begin_upload(
+                "doc.txt", total_size=1024, content_type="text/plain"
+            )
+            assert upload.content_type == "text/plain"
+
+
+class TestAsyncResumeUpload:
+    @pytest.mark.asyncio
+    async def test_resume_upload_puts_with_server_content_type(self):
+        # Regression: the resume path rebuilds state purely from the server, so
+        # the part PUT must carry the content-type the refresh response reports
+        # (the GCS signed URL is bound to it).
+        client = _make_client()
+        refresh_resp = _mock_response(
+            {
+                "session_token": "new-tok",
+                "session_expires_at": "2024-01-01T03:00:00Z",
+                "content_type": "text/plain",
+                "parts": [
+                    {
+                        "part_number": 1,
+                        "byte_range_start": 0,
+                        "byte_range_end": 1023,
+                        "url": "https://signed.example.com/part1",
+                        "url_expires_at": "2024-01-01T03:00:00Z",
+                    },
+                ],
+            }
+        )
+        put_resp = MagicMock()
+        put_resp.headers = {"ETag": '"etag1"'}
+        with (
+            patch.object(
+                client._transport,
+                "request",
+                new_callable=AsyncMock,
+                return_value=refresh_resp,
+            ),
+            patch.object(
+                client._transport,
+                "request_raw_put",
+                new_callable=AsyncMock,
+                return_value=put_resp,
+            ) as mock_put,
+        ):
+            upload = await client.resume_upload("u-old")
+            assert upload.content_type == "text/plain"
+            await upload.send_chunk(b"x" * 1024, part_number=1)
+            _, kwargs = mock_put.call_args
+            assert kwargs["headers"] == {"Content-Type": "text/plain"}
+
+    @pytest.mark.asyncio
+    async def test_resume_upload_defaults_content_type_when_absent(self):
+        client = _make_client()
+        resp = _mock_response(
+            {
+                "session_token": "new-tok",
+                "session_expires_at": "2024-01-01T03:00:00Z",
+                "parts": [],
+            }
+        )
+        with patch.object(
+            client._transport, "request", new_callable=AsyncMock, return_value=resp
+        ):
+            upload = await client.resume_upload("u-old")
+            assert upload.content_type == "application/octet-stream"

{riffsdk-0.4.0 → riffsdk-0.4.2}/tests/test_client.py

@@ -867,6 +867,34 @@ class TestBeginUpload:
             assert body["size"] == 2048
             assert body["part_size"] == 1024
 
+    def test_begin_upload_threads_content_type(self):
+        client = _make_client()
+        resp = _mock_response(
+            {
+                "upload_id": "u-1",
+                "key": "doc.txt",
+                "part_count": 1,
+                "part_size": 1024,
+                "expires_at": "2024-01-01T02:00:00Z",
+                "session_token": "sess-tok",
+                "session_expires_at": "2024-01-01T01:00:00Z",
+                "parts": [
+                    {
+                        "part_number": 1,
+                        "byte_range_start": 0,
+                        "byte_range_end": 1023,
+                        "url": "https://signed.example.com/part1",
+                        "url_expires_at": "2024-01-01T01:00:00Z",
+                    },
+                ],
+            }
+        )
+        with patch.object(client._transport, "request", return_value=resp):
+            upload = client.begin_upload(
+                "doc.txt", total_size=1024, content_type="text/plain"
+            )
+            assert upload.content_type == "text/plain"
+
     def test_begin_upload_with_conditions(self):
         client = _make_client()
         resp = _mock_response(
@@ -920,6 +948,55 @@ class TestResumeUpload:
             args, kwargs = mock_req.call_args
             assert args == ("POST", "/storage/v1/uploads/u-old/refresh")
 
+    def test_resume_upload_puts_with_server_content_type(self):
+        # Regression: the resume path rebuilds state purely from the server, so
+        # the part PUT must carry the content-type the refresh response reports
+        # (the GCS signed URL is bound to it). Hardcoding octet-stream here
+        # caused a 403 for non-default content-types.
+        client = _make_client()
+        refresh_resp = _mock_response(
+            {
+                "session_token": "new-tok",
+                "session_expires_at": "2024-01-01T03:00:00Z",
+                "content_type": "text/plain",
+                "parts": [
+                    {
+                        "part_number": 1,
+                        "byte_range_start": 0,
+                        "byte_range_end": 1023,
+                        "url": "https://signed.example.com/part1",
+                        "url_expires_at": "2024-01-01T03:00:00Z",
+                    },
+                ],
+            }
+        )
+        put_resp = MagicMock()
+        put_resp.headers = {"ETag": '"etag1"'}
+        with (
+            patch.object(client._transport, "request", return_value=refresh_resp),
+            patch.object(
+                client._transport, "request_raw_put", return_value=put_resp
+            ) as mock_put,
+        ):
+            upload = client.resume_upload("u-old")
+            assert upload.content_type == "text/plain"
+            upload.send_chunk(b"x" * 1024, part_number=1)
+            _, kwargs = mock_put.call_args
+            assert kwargs["headers"] == {"Content-Type": "text/plain"}
+
+    def test_resume_upload_defaults_content_type_when_absent(self):
+        client = _make_client()
+        resp = _mock_response(
+            {
+                "session_token": "new-tok",
+                "session_expires_at": "2024-01-01T03:00:00Z",
+                "parts": [],
+            }
+        )
+        with patch.object(client._transport, "request", return_value=resp):
+            upload = client.resume_upload("u-old")
+            assert upload.content_type == "application/octet-stream"
+
 
 class TestUploadFile:
     def test_upload_file_orchestrates_upload(self):

{riffsdk-0.4.0 → riffsdk-0.4.2}/tests/test_integration.py

@@ -6,7 +6,7 @@ Prerequisites:
 
 Configuration via environment variables:
     RIFF_INTEGRATION_TEST=true   (required — tests are skipped without this)
-    RIFF_BASE_URL                (default: http://localhost:8080)
+    RIFF_BASE_URL                (default: http://localhost:8080/riff-api)
     RIFF_API_KEY                 (default: test-key)
     RIFF_PROJECT_ID              (default: test-project)
 """
@@ -30,7 +30,7 @@ from riffsdk.storage.exceptions import (
     VersionConflictError,
 )
 
-BASE_URL = os.environ.get("RIFF_BASE_URL", "http://localhost:8080")
+BASE_URL = os.environ.get("RIFF_BASE_URL", "http://localhost:8080/riff-api")
 API_KEY = os.environ.get("RIFF_API_KEY", "test-key")
 PROJECT_ID = os.environ.get("RIFF_PROJECT_ID", "test-project")
 
@@ -321,6 +321,41 @@ class TestResumeUpload:
         data = client.get(key)
         assert data == content
 
+    def test_resume_with_non_default_content_type(self, client: StorageClient, prefix):
+        # Regression: GCS signed URLs are bound to the content-type passed at
+        # begin_upload. The resume path rebuilds state from the server, so the
+        # part PUT must carry that same content-type or GCS returns 403.
+        key = f"{prefix}resume-text.txt"
+        chunk_size = 1024 * 1024
+        content = b"resume-content-type-check " * 50_000  # > 2 chunks
+        content = content[: 2 * chunk_size]
+
+        upload = client.begin_upload(
+            key,
+            total_size=len(content),
+            content_type="text/plain",
+            chunk_size=chunk_size,
+        )
+        upload_id = upload.upload_id
+        upload.send_chunk(content[:chunk_size], part_number=1)
+
+        resumed = client.resume_upload(upload_id)
+        # The server reports the upload's content-type on refresh, and the SDK
+        # uses it for the part PUT.
+        assert resumed.content_type == "text/plain"
+        # This PUT 403'd before the fix (hardcoded application/octet-stream).
+        resumed.send_chunk(content[chunk_size:], part_number=2)
+
+        all_etags = {**upload._etags, **resumed._etags}
+        parts = [(num, etag) for num, etag in sorted(all_etags.items())]
+        result = resumed.complete(parts=parts)
+        assert result.key == key
+
+        # The bytes round-trip — the resumed PUT was accepted by GCS.
+        assert client.get(key) == content
+        # The uploaded content-type is persisted on the stored object.
+        assert client.stat(key).content_type == "text/plain"
+
 
 class TestListDelimiter:
     def test_list_with_delimiter(self, client: StorageClient, prefix: str):
@@ -838,6 +873,40 @@ class TestAsyncResumeUpload:
         data = await async_client.get(key)
         assert data == content
 
+    @pytest.mark.asyncio
+    async def test_resume_with_non_default_content_type(
+        self, async_client: AsyncStorageClient, async_prefix: str
+    ):
+        # Regression: the resumed part PUT must carry the original content-type
+        # the GCS signed URL was bound to, or GCS returns 403.
+        key = f"{async_prefix}resume-text.txt"
+        chunk_size = 1024 * 1024
+        content = b"resume-content-type-check " * 50_000
+        content = content[: 2 * chunk_size]
+
+        upload = await async_client.begin_upload(
+            key,
+            total_size=len(content),
+            content_type="text/plain",
+            chunk_size=chunk_size,
+        )
+        upload_id = upload.upload_id
+        await upload.send_chunk(content[:chunk_size], part_number=1)
+
+        resumed = await async_client.resume_upload(upload_id)
+        assert resumed.content_type == "text/plain"
+        await resumed.send_chunk(content[chunk_size:], part_number=2)
+
+        all_etags = {**upload._etags, **resumed._etags}
+        parts = [(num, etag) for num, etag in sorted(all_etags.items())]
+        result = await resumed.complete(parts=parts)
+        assert result.key == key
+
+        # The bytes round-trip — the resumed PUT was accepted by GCS.
+        assert await async_client.get(key) == content
+        # The uploaded content-type is persisted on the stored object.
+        assert (await async_client.stat(key)).content_type == "text/plain"
+
 
 class TestAsyncResumableUpload:
     @pytest.mark.asyncio

{riffsdk-0.4.0 → riffsdk-0.4.2}/tests/test_upload.py

@@ -26,7 +26,10 @@ def _make_parts(count: int = 2) -> list[UploadPart]:
 
 
 def _make_sync_upload(
-    *, transport: MagicMock | None = None, sessions: SessionStore | None = None
+    *,
+    transport: MagicMock | None = None,
+    sessions: SessionStore | None = None,
+    content_type: str = "application/octet-stream",
 ) -> ResumableUpload:
     transport = transport or MagicMock()
     sessions = sessions or SessionStore()
@@ -42,11 +45,15 @@ def _make_sync_upload(
         session_token="sess-tok",
         session_expires_at=_FAR_FUTURE,
         parts=_make_parts(),
+        content_type=content_type,
     )
 
 
 def _make_async_upload(
-    *, transport: MagicMock | None = None, sessions: SessionStore | None = None
+    *,
+    transport: MagicMock | None = None,
+    sessions: SessionStore | None = None,
+    content_type: str = "application/octet-stream",
 ) -> AsyncResumableUpload:
     transport = transport or MagicMock()
     sessions = sessions or SessionStore()
@@ -62,6 +69,7 @@ def _make_async_upload(
         session_token="sess-tok",
         session_expires_at=_FAR_FUTURE,
         parts=_make_parts(),
+        content_type=content_type,
     )
 
 
@@ -138,6 +146,18 @@ class TestSendChunk:
         with pytest.raises(StorageTransportError):
             upload.send_chunk(b"x" * 1024)
 
+    def test_uses_upload_content_type_header(self):
+        transport = MagicMock()
+        put_resp = MagicMock()
+        put_resp.headers = {"ETag": '"etag1"'}
+        transport.request_raw_put.return_value = put_resp
+
+        upload = _make_sync_upload(transport=transport, content_type="text/plain")
+        upload.send_chunk(b"x" * 1024)
+
+        _, kwargs = transport.request_raw_put.call_args
+        assert kwargs["headers"] == {"Content-Type": "text/plain"}
+
 
 class TestRefreshSession:
     def test_updates_token_and_parts(self):
@@ -285,6 +305,19 @@ class TestAsyncSendChunk:
         with pytest.raises(StorageTransportError):
             await upload.send_chunk(b"x" * 1024)
 
+    @pytest.mark.asyncio
+    async def test_uses_upload_content_type_header(self):
+        transport = MagicMock()
+        put_resp = MagicMock()
+        put_resp.headers = {"ETag": '"etag1"'}
+        transport.request_raw_put = AsyncMock(return_value=put_resp)
+
+        upload = _make_async_upload(transport=transport, content_type="text/plain")
+        await upload.send_chunk(b"x" * 1024)
+
+        _, kwargs = transport.request_raw_put.call_args
+        assert kwargs["headers"] == {"Content-Type": "text/plain"}
+
 
 class TestAsyncRefreshSession:
     @pytest.mark.asyncio