diffio 0.1.80__tar.gz → 0.1.82__tar.gz

{diffio-0.1.80/src/diffio.egg-info → diffio-0.1.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffio
-Version: 0.1.80
+Version: 0.1.82
 Summary: Python SDK for the Diffio API.
 Author: Diffio
 License: MIT
@@ -155,6 +155,14 @@ print(info["apiProjectId"], info["generationId"])
 restoration or final settlement is still pending; stage progress alone does not
 indicate overall completion.
 
+For Diffio 2.0, `complete` means restored media is ready. Transcription can still
+be `pending`, become `available` later, or finish as `unavailable`. Read
+`progress.transcription.status` independently; `progress.transcription` is `None`
+for older responses that do not report availability. A completed generation
+remains successful if transcription is unavailable. Completion webhooks expose
+the same optional `event.transcription` object; a later transcript does not emit
+another `generation.completed` event.
+
 ```py
 from diffio import DiffioClient
 
@@ -165,6 +173,8 @@ progress = client.generations.get_progress(
 )
 
 print(progress.status)
+if progress.transcription is not None:
+    print(progress.transcription.status)
 ```
 
 ## Generation download
@@ -186,16 +196,41 @@ print(download.downloadUrl)
 If you only need the URL, use `client.generations.get_download`.
 
 Set `downloadType="transcript"` to download the transcript JSON artifact when the generation has one.
+Pending transcripts return `DiffioApiError` with `statusCode == 409` and
+`responseBody["code"] == "TRANSCRIPT_PENDING"`. Unavailable transcripts return
+`statusCode == 404` and `responseBody["code"] == "TRANSCRIPT_UNAVAILABLE"`. These
+responses include `responseBody["transcription"]["status"]`. Check the error code
+to distinguish them from other 409 or 404 errors.
 
 ```py
-transcript = client.generations.download(
-    generationId="gen_123",
-    apiProjectId="proj_123",
-    downloadType="transcript",
-    downloadFilePath="word_timestamps.json",
-)
+from diffio import DiffioApiError
+
+try:
+    transcript = client.generations.download(
+        generationId="gen_123",
+        apiProjectId="proj_123",
+        downloadType="transcript",
+        downloadFilePath="word_timestamps.json",
+    )
+except DiffioApiError as exc:
+    body = exc.responseBody if isinstance(exc.responseBody, dict) else {}
+    if exc.statusCode == 409 and body.get("code") == "TRANSCRIPT_PENDING":
+        print("Transcript is pending; check progress and retry later.")
+    elif exc.statusCode == 404 and body.get("code") == "TRANSCRIPT_UNAVAILABLE":
+        print("Transcript is unavailable; restored media remains available.")
+    else:
+        raise
 ```
 
+`restore_audio(downloadType="transcript")` also makes one download request after
+media completion. It does not wait for a pending transcript. With its default
+`raiseOnError=False`, it returns `(None, info)` and preserves the API error in
+`info["statusCode"]` and `info["responseBody"]`; `info["status"]` can still be
+`complete` because media restoration succeeded. With `raiseOnError=True`, it raises
+the same `DiffioApiError` and attaches the metadata as `exc.restoreInfo`. Callers
+can poll progress and retry the transcript download explicitly. Audio and video
+downloads proceed independently of transcription availability.
+
 ## Account, keys, usage, and webhook configuration
 
 Agent keys can manage account settings, scoped keys, usage, and webhook endpoints.

{diffio-0.1.80 → diffio-0.1.82}/README.md

@@ -127,6 +127,14 @@ print(info["apiProjectId"], info["generationId"])
 restoration or final settlement is still pending; stage progress alone does not
 indicate overall completion.
 
+For Diffio 2.0, `complete` means restored media is ready. Transcription can still
+be `pending`, become `available` later, or finish as `unavailable`. Read
+`progress.transcription.status` independently; `progress.transcription` is `None`
+for older responses that do not report availability. A completed generation
+remains successful if transcription is unavailable. Completion webhooks expose
+the same optional `event.transcription` object; a later transcript does not emit
+another `generation.completed` event.
+
 ```py
 from diffio import DiffioClient
 
@@ -137,6 +145,8 @@ progress = client.generations.get_progress(
 )
 
 print(progress.status)
+if progress.transcription is not None:
+    print(progress.transcription.status)
 ```
 
 ## Generation download
@@ -158,16 +168,41 @@ print(download.downloadUrl)
 If you only need the URL, use `client.generations.get_download`.
 
 Set `downloadType="transcript"` to download the transcript JSON artifact when the generation has one.
+Pending transcripts return `DiffioApiError` with `statusCode == 409` and
+`responseBody["code"] == "TRANSCRIPT_PENDING"`. Unavailable transcripts return
+`statusCode == 404` and `responseBody["code"] == "TRANSCRIPT_UNAVAILABLE"`. These
+responses include `responseBody["transcription"]["status"]`. Check the error code
+to distinguish them from other 409 or 404 errors.
 
 ```py
-transcript = client.generations.download(
-    generationId="gen_123",
-    apiProjectId="proj_123",
-    downloadType="transcript",
-    downloadFilePath="word_timestamps.json",
-)
+from diffio import DiffioApiError
+
+try:
+    transcript = client.generations.download(
+        generationId="gen_123",
+        apiProjectId="proj_123",
+        downloadType="transcript",
+        downloadFilePath="word_timestamps.json",
+    )
+except DiffioApiError as exc:
+    body = exc.responseBody if isinstance(exc.responseBody, dict) else {}
+    if exc.statusCode == 409 and body.get("code") == "TRANSCRIPT_PENDING":
+        print("Transcript is pending; check progress and retry later.")
+    elif exc.statusCode == 404 and body.get("code") == "TRANSCRIPT_UNAVAILABLE":
+        print("Transcript is unavailable; restored media remains available.")
+    else:
+        raise
 ```
 
+`restore_audio(downloadType="transcript")` also makes one download request after
+media completion. It does not wait for a pending transcript. With its default
+`raiseOnError=False`, it returns `(None, info)` and preserves the API error in
+`info["statusCode"]` and `info["responseBody"]`; `info["status"]` can still be
+`complete` because media restoration succeeded. With `raiseOnError=True`, it raises
+the same `DiffioApiError` and attaches the metadata as `exc.restoreInfo`. Callers
+can poll progress and retry the transcript download explicitly. Audio and video
+downloads proceed independently of transcription availability.
+
 ## Account, keys, usage, and webhook configuration
 
 Agent keys can manage account settings, scoped keys, usage, and webhook endpoints.

{diffio-0.1.80 → diffio-0.1.82}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "diffio"
-version = "0.1.80"
+version = "0.1.82"
 description = "Python SDK for the Diffio API."
 readme = "README.md"
 requires-python = ">=3.8"

{diffio-0.1.80 → diffio-0.1.82}/src/diffio/__init__.py

@@ -21,6 +21,7 @@ from .types import (
     GenerationDownloadResponse,
     GenerationProgressResponse,
     GenerationProgressStage,
+    GenerationTranscription,
     GenerationWebhookEvent,
     GenerationWebhookStatus,
     ListProjectGenerationsResponse,
@@ -28,6 +29,7 @@ from .types import (
     ModelKey,
     ProjectGenerationSummary,
     ProjectSummary,
+    TranscriptionStatus,
     UsageSummaryResponse,
     WebhookConfigureResponse,
     WebhookEventType,
@@ -51,6 +53,7 @@ __all__ = [
     "GenerationDownloadResponse",
     "GenerationProgressResponse",
     "GenerationProgressStage",
+    "GenerationTranscription",
     "GenerationWebhookEvent",
     "GenerationWebhookStatus",
     "GenerationsClient",
@@ -61,6 +64,7 @@ __all__ = [
     "ProjectSummary",
     "ProjectsClient",
     "RequestOptions",
+    "TranscriptionStatus",
     "UsageClient",
     "UsageSummaryResponse",
     "WebhookConfigureResponse",
@@ -70,4 +74,4 @@ __all__ = [
     "WebhooksClient",
 ]
 
-__version__ = "0.1.80"
+__version__ = "0.1.82"

{diffio-0.1.80 → diffio-0.1.82}/src/diffio/client.py

@@ -449,6 +449,9 @@ class DiffioClient:
         """
         Polls generation progress until completion or failure.
 
+        For Diffio 2.0, completion means restored media is ready. The returned
+        transcription state can still be pending or unavailable.
+
         Parameters
         ----------
         generationId : str
@@ -513,13 +516,20 @@ class DiffioClient:
         apiProjectId : str
             The project id that owns the generation.
         downloadType : str, optional
-            Optional download type, audio, mp3, or video.
+            Optional download type, audio, mp3, video, or transcript.
 
         Returns
         -------
         GenerationDownloadResponse
             Signed download URL and file metadata.
 
+        Raises
+        ------
+        DiffioApiError
+            Transcript downloads return statusCode 409 with responseBody code
+            TRANSCRIPT_PENDING, or 404 with code TRANSCRIPT_UNAVAILABLE. Overall
+            generation completion does not guarantee transcript availability.
+
         Examples
         --------
         from diffio import DiffioClient
@@ -906,7 +916,7 @@ class GenerationsClient:
         downloadFilePath : str
             Local file path to write the downloaded media to.
         downloadType : str, optional
-            Optional download type, audio, mp3, or video.
+            Optional download type, audio, mp3, video, or transcript.
 
         Returns
         -------
@@ -1495,6 +1505,8 @@ def _init_restore_metadata():
         "errorDetails": None,
         "exceptionType": None,
         "exceptionMessage": None,
+        "statusCode": None,
+        "responseBody": None,
     }
 
 
@@ -1502,6 +1514,9 @@ def _set_restore_error(metadata, exc):
     metadata["error"] = str(exc)
     metadata["exceptionType"] = exc.__class__.__name__
     metadata["exceptionMessage"] = str(exc)
+    if isinstance(exc, DiffioApiError):
+        metadata["statusCode"] = exc.statusCode
+        metadata["responseBody"] = exc.responseBody
 
 
 def _attach_restore_metadata(exc, metadata):

{diffio-0.1.80 → diffio-0.1.82}/src/diffio/types.py

@@ -172,6 +172,15 @@ class GenerationProgressStage:
         )
 
 
+class GenerationTranscription:
+    def __init__(self, status):
+        self.status = status
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(status=data["status"])
+
+
 class GenerationProgressResponse:
     def __init__(
         self,
@@ -184,6 +193,7 @@ class GenerationProgressResponse:
         restoredVideo,
         error,
         errorDetails,
+        transcription=None,
     ):
         self.generationId = generationId
         self.apiProjectId = apiProjectId
@@ -194,10 +204,12 @@ class GenerationProgressResponse:
         self.restoredVideo = restoredVideo
         self.error = error
         self.errorDetails = errorDetails
+        self.transcription = transcription
 
     @classmethod
     def from_dict(cls, data):
         restored_video = data.get("restoredVideo")
+        transcription = data.get("transcription")
         return cls(
             generationId=data["generationId"],
             apiProjectId=data["apiProjectId"],
@@ -208,6 +220,10 @@ class GenerationProgressResponse:
             restoredVideo=(GenerationProgressStage.from_dict(restored_video) if restored_video else None),
             error=data.get("error"),
             errorDetails=data.get("errorDetails"),
+            transcription=(
+                GenerationTranscription.from_dict(transcription)
+                if transcription is not None else None
+            ),
         )
 
 
@@ -392,6 +408,7 @@ class GenerationWebhookEvent:
         modelKey,
         error,
         errorDetails,
+        transcription=None,
     ):
         self.eventType = eventType
         self.eventId = eventId
@@ -404,9 +421,11 @@ class GenerationWebhookEvent:
         self.modelKey = modelKey
         self.error = error
         self.errorDetails = errorDetails
+        self.transcription = transcription
 
     @classmethod
     def from_dict(cls, data):
+        transcription = data.get("transcription")
         return cls(
             eventType=data["eventType"],
             eventId=data["eventId"],
@@ -419,6 +438,10 @@ class GenerationWebhookEvent:
             modelKey=data.get("modelKey"),
             error=data.get("error"),
             errorDetails=data.get("errorDetails"),
+            transcription=(
+                GenerationTranscription.from_dict(transcription)
+                if transcription is not None else None
+            ),
         )
 
 
@@ -438,3 +461,4 @@ WebhookEventType = (
     "generation.completed",
 )
 GenerationWebhookStatus = ("queued", "processing", "error", "complete")
+TranscriptionStatus = ("pending", "available", "unavailable")

{diffio-0.1.80 → diffio-0.1.82/src/diffio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffio
-Version: 0.1.80
+Version: 0.1.82
 Summary: Python SDK for the Diffio API.
 Author: Diffio
 License: MIT
@@ -155,6 +155,14 @@ print(info["apiProjectId"], info["generationId"])
 restoration or final settlement is still pending; stage progress alone does not
 indicate overall completion.
 
+For Diffio 2.0, `complete` means restored media is ready. Transcription can still
+be `pending`, become `available` later, or finish as `unavailable`. Read
+`progress.transcription.status` independently; `progress.transcription` is `None`
+for older responses that do not report availability. A completed generation
+remains successful if transcription is unavailable. Completion webhooks expose
+the same optional `event.transcription` object; a later transcript does not emit
+another `generation.completed` event.
+
 ```py
 from diffio import DiffioClient
 
@@ -165,6 +173,8 @@ progress = client.generations.get_progress(
 )
 
 print(progress.status)
+if progress.transcription is not None:
+    print(progress.transcription.status)
 ```
 
 ## Generation download
@@ -186,16 +196,41 @@ print(download.downloadUrl)
 If you only need the URL, use `client.generations.get_download`.
 
 Set `downloadType="transcript"` to download the transcript JSON artifact when the generation has one.
+Pending transcripts return `DiffioApiError` with `statusCode == 409` and
+`responseBody["code"] == "TRANSCRIPT_PENDING"`. Unavailable transcripts return
+`statusCode == 404` and `responseBody["code"] == "TRANSCRIPT_UNAVAILABLE"`. These
+responses include `responseBody["transcription"]["status"]`. Check the error code
+to distinguish them from other 409 or 404 errors.
 
 ```py
-transcript = client.generations.download(
-    generationId="gen_123",
-    apiProjectId="proj_123",
-    downloadType="transcript",
-    downloadFilePath="word_timestamps.json",
-)
+from diffio import DiffioApiError
+
+try:
+    transcript = client.generations.download(
+        generationId="gen_123",
+        apiProjectId="proj_123",
+        downloadType="transcript",
+        downloadFilePath="word_timestamps.json",
+    )
+except DiffioApiError as exc:
+    body = exc.responseBody if isinstance(exc.responseBody, dict) else {}
+    if exc.statusCode == 409 and body.get("code") == "TRANSCRIPT_PENDING":
+        print("Transcript is pending; check progress and retry later.")
+    elif exc.statusCode == 404 and body.get("code") == "TRANSCRIPT_UNAVAILABLE":
+        print("Transcript is unavailable; restored media remains available.")
+    else:
+        raise
 ```
 
+`restore_audio(downloadType="transcript")` also makes one download request after
+media completion. It does not wait for a pending transcript. With its default
+`raiseOnError=False`, it returns `(None, info)` and preserves the API error in
+`info["statusCode"]` and `info["responseBody"]`; `info["status"]` can still be
+`complete` because media restoration succeeded. With `raiseOnError=True`, it raises
+the same `DiffioApiError` and attaches the metadata as `exc.restoreInfo`. Callers
+can poll progress and retry the transcript download explicitly. Audio and video
+downloads proceed independently of transcription availability.
+
 ## Account, keys, usage, and webhook configuration
 
 Agent keys can manage account settings, scoped keys, usage, and webhook endpoints.

{diffio-0.1.80 → diffio-0.1.82}/src/diffio.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ src/diffio.egg-info/dependency_links.txt
 src/diffio.egg-info/requires.txt
 src/diffio.egg-info/top_level.txt
 tests/test_client.py
-tests/test_emulator_e2e.py
+tests/test_emulator_e2e.py
+tests/test_transcription.py

{diffio-0.1.80 → diffio-0.1.82}/tests/test_client.py

@@ -449,7 +449,8 @@ def test_advertised_models_match_runtime_model_support():
     assert MODEL_ENDPOINTS["diffio-3.4"] == "diffio-3.4-generation"
 
 
-def test_restore_audio_runs_full_flow_and_downloads(tmp_path: Path, monkeypatch):
+@pytest.mark.parametrize("transcription_status", [None, "pending", "available", "unavailable"])
+def test_restore_audio_runs_full_flow_and_downloads(tmp_path, monkeypatch, transcription_status):
     status_sequence = ["queued", "processing", "complete"]
 
     def handler(request: httpx.Request) -> httpx.Response:
@@ -492,6 +493,7 @@ def test_restore_audio_runs_full_flow_and_downloads(tmp_path: Path, monkeypatch)
             return httpx.Response(
                 200,
                 json={
+                    **({"transcription": {"status": transcription_status}} if transcription_status else {}),
                     "generationId": "gen_123",
                     "apiProjectId": "proj_abc",
                     "status": status,
@@ -566,6 +568,12 @@ def test_restore_audio_runs_full_flow_and_downloads(tmp_path: Path, monkeypatch)
     assert info["downloadUrl"] == "https://download.test/output.mp3"
     assert info["error"] is None
     assert info["ok"] is True
+    assert info["statusCode"] is None
+    assert info["responseBody"] is None
+    if transcription_status is None:
+        assert info["progress"].transcription is None
+    else:
+        assert info["progress"].transcription.status == transcription_status
 
 
 def test_create_generation_rejects_unknown_model():

diffio-0.1.82/tests/test_transcription.py

@@ -0,0 +1,182 @@
+import base64
+import json
+from datetime import datetime, timezone
+from types import SimpleNamespace
+
+import httpx
+import pytest
+from svix.webhooks import Webhook
+
+from diffio import DiffioApiError, DiffioClient, GenerationTranscription, TranscriptionStatus
+
+
+def completed_progress(transcription_status):
+    payload = {
+        "generationId": "gen_123",
+        "apiProjectId": "proj_123",
+        "status": "complete",
+        "hasVideo": False,
+        "preProcessing": {"status": "complete", "progress": 100},
+        "inference": {"status": "complete", "progress": 100},
+    }
+    if transcription_status is not None:
+        payload["transcription"] = {"status": transcription_status}
+    return payload
+
+
+@pytest.mark.parametrize("transcription_status", [None, *TranscriptionStatus])
+@pytest.mark.parametrize("method", ["wait_for_generation", "wait_for_complete"])
+def test_media_completion_does_not_wait_for_transcription(transcription_status, method):
+    requests = []
+    progress_updates = []
+
+    def handler(request):
+        requests.append(request)
+        assert request.url.path == "/v1/get_generation_progress"
+        return httpx.Response(200, json=completed_progress(transcription_status))
+
+    with httpx.Client(base_url="https://api.test", transport=httpx.MockTransport(handler)) as http_client:
+        client = DiffioClient(apiKey="diffio_test", httpClient=http_client)
+        wait = client.wait_for_generation if method == "wait_for_generation" else client.generations.wait_for_complete
+        progress = wait(
+            generationId="gen_123",
+            apiProjectId="proj_123",
+            pollInterval=0,
+            timeout=5,
+            onProgress=progress_updates.append,
+        )
+
+    assert len(requests) == 1
+    assert progress_updates == [progress]
+    assert progress.status == "complete"
+    if transcription_status is None:
+        assert progress.transcription is None
+    else:
+        assert isinstance(progress.transcription, GenerationTranscription)
+        assert progress.transcription.status == transcription_status
+
+
+@pytest.mark.parametrize("transcription_status", [None, *TranscriptionStatus])
+def test_verified_webhook_preserves_transcription_state(transcription_status):
+    payload = {
+        "eventType": "generation.completed",
+        "eventId": "evt_123",
+        "createdAt": "2026-09-14T00:00:00Z",
+        "apiKeyId": "key_123",
+        "apiProjectId": "proj_123",
+        "generationId": "gen_123",
+        "status": "complete",
+        "modelKey": "diffio-2",
+        "hasVideo": False,
+    }
+    if transcription_status is not None:
+        payload["transcription"] = {"status": transcription_status}
+    body = json.dumps(payload)
+    secret = "whsec_" + base64.b64encode(b"test-webhook-secret").decode("ascii")
+    timestamp = datetime.now(timezone.utc)
+    headers = {
+        "svix-id": "msg_123",
+        "svix-timestamp": str(int(timestamp.timestamp())),
+        "svix-signature": Webhook(secret).sign("msg_123", timestamp, body),
+    }
+
+    with DiffioClient(apiKey="diffio_test") as client:
+        event = client.webhooks.verify_signature(payload=body.encode("utf-8"), headers=headers, secret=secret)
+
+    assert event.status == "complete"
+    assert event.eventType == "generation.completed"
+    if transcription_status is None:
+        assert event.transcription is None
+    else:
+        assert isinstance(event.transcription, GenerationTranscription)
+        assert event.transcription.status == transcription_status
+
+
+@pytest.fixture(params=[
+    (409, "TRANSCRIPT_PENDING", "pending", "Transcript is not ready yet."),
+    (404, "TRANSCRIPT_UNAVAILABLE", "unavailable", "Transcript is unavailable."),
+])
+def transcript_error(request):
+    status_code, code, status, message = request.param
+    return status_code, {
+        "error": message,
+        "code": code,
+        "transcription": {"status": status},
+    }
+
+
+@pytest.mark.parametrize("method", ["get_download", "download"])
+def test_transcript_download_preserves_availability_errors(tmp_path, transcript_error, method):
+    status_code, body = transcript_error
+    requests = []
+    output_path = tmp_path / "word_timestamps.json"
+    output_path.write_text("existing transcript", encoding="utf-8")
+
+    def handler(request):
+        requests.append(request)
+        assert request.url.path == "/v1/get_generation_download"
+        assert json.loads(request.content)["downloadType"] == "transcript"
+        return httpx.Response(status_code, json=body)
+
+    with httpx.Client(base_url="https://api.test", transport=httpx.MockTransport(handler)) as http_client:
+        client = DiffioClient(apiKey="diffio_test", httpClient=http_client)
+        arguments = {
+            "generationId": "gen_123",
+            "apiProjectId": "proj_123",
+            "downloadType": "transcript",
+        }
+        if method == "download":
+            arguments["downloadFilePath"] = output_path
+        with pytest.raises(DiffioApiError) as raised:
+            getattr(client.generations, method)(**arguments)
+
+    assert len(requests) == 1
+    assert raised.value.message == body["error"]
+    assert raised.value.statusCode == status_code
+    assert raised.value.responseBody == body
+    assert output_path.read_text(encoding="utf-8") == "existing transcript"
+
+
+@pytest.mark.parametrize("raise_on_error", [False, True])
+def test_restore_transcript_preserves_errors_after_media_completion(monkeypatch, transcript_error, raise_on_error):
+    status_code, body = transcript_error
+    requests = []
+
+    def handler(request):
+        requests.append(request.url.path)
+        if request.url.path == "/v1/get_generation_progress":
+            return httpx.Response(200, json=completed_progress("pending"))
+        assert request.url.path == "/v1/get_generation_download"
+        assert json.loads(request.content)["downloadType"] == "transcript"
+        return httpx.Response(status_code, json=body)
+
+    with httpx.Client(base_url="https://api.test", transport=httpx.MockTransport(handler)) as http_client:
+        client = DiffioClient(apiKey="diffio_test", httpClient=http_client)
+        monkeypatch.setattr(client.audio_isolation, "isolate", lambda **kwargs: SimpleNamespace(
+            project=SimpleNamespace(apiProjectId="proj_123"),
+            generation=SimpleNamespace(generationId="gen_123"),
+        ))
+        arguments = {
+            "filePath": "sample.wav",
+            "model": "diffio-2",
+            "downloadType": "transcript",
+            "raiseOnError": raise_on_error,
+        }
+        if raise_on_error:
+            with pytest.raises(DiffioApiError) as raised:
+                client.restore_audio(**arguments)
+            assert raised.value.statusCode == status_code
+            assert raised.value.responseBody == body
+            info = raised.value.restoreInfo
+        else:
+            content, info = client.restore_audio(**arguments)
+            assert content is None
+
+    assert requests == ["/v1/get_generation_progress", "/v1/get_generation_download"]
+    assert info["status"] == "complete"
+    assert info["progress"].transcription.status == "pending"
+    assert info["stage"] == "download_info"
+    assert info["ok"] is False
+    assert info["exceptionType"] == "DiffioApiError"
+    assert info["statusCode"] == status_code
+    assert info["responseBody"] == body