diffio 0.1.6__tar.gz → 0.1.7__tar.gz

{diffio-0.1.6/src/diffio.egg-info → diffio-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffio
-Version: 0.1.6
+Version: 0.1.7
 Summary: Python SDK for the Diffio API.
 Author: Diffio
 License: MIT
@@ -87,7 +87,7 @@ project = client.create_project(
 
 generation = client.create_generation(
     apiProjectId=project.apiProjectId,
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
 )
 
@@ -102,7 +102,7 @@ from diffio import DiffioClient
 client = DiffioClient(apiKey="diffio_live_...")
 result = client.audio_isolation.isolate(
     filePath="sample.wav",
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
 )
 
@@ -119,7 +119,7 @@ from diffio import DiffioClient
 client = DiffioClient(apiKey="diffio_live_...")
 audio_bytes, info = client.restore_audio(
     filePath="sample.wav",
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
     onProgress=lambda progress: print(progress.status),
 )
@@ -165,6 +165,36 @@ 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.
+
+```py
+transcript = client.generations.download(
+    generationId="gen_123",
+    apiProjectId="proj_123",
+    downloadType="transcript",
+    downloadFilePath="word_timestamps.json",
+)
+```
+
+## Account, keys, usage, and webhook configuration
+
+Agent keys can manage account settings, scoped keys, usage, and webhook endpoints.
+
+```py
+settings = client.account.get_settings()
+key = client.api_keys.create(
+    label="Backend worker",
+    scopes=["projects:read", "projects:write", "generations:read", "generations:write", "artifacts:read"],
+)
+usage = client.usage.summary(apiKeyId=key.keyId)
+webhook = client.webhooks.configure(
+    mode="live",
+    url="https://example.com/webhooks/diffio",
+    eventTypes=["generation.completed", "generation.failed"],
+    apiKeyId=key.keyId,
+)
+```
+
 ## List projects
 
 ```py

{diffio-0.1.6 → diffio-0.1.7}/README.md

@@ -59,7 +59,7 @@ project = client.create_project(
 
 generation = client.create_generation(
     apiProjectId=project.apiProjectId,
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
 )
 
@@ -74,7 +74,7 @@ from diffio import DiffioClient
 client = DiffioClient(apiKey="diffio_live_...")
 result = client.audio_isolation.isolate(
     filePath="sample.wav",
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
 )
 
@@ -91,7 +91,7 @@ from diffio import DiffioClient
 client = DiffioClient(apiKey="diffio_live_...")
 audio_bytes, info = client.restore_audio(
     filePath="sample.wav",
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
     onProgress=lambda progress: print(progress.status),
 )
@@ -137,6 +137,36 @@ 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.
+
+```py
+transcript = client.generations.download(
+    generationId="gen_123",
+    apiProjectId="proj_123",
+    downloadType="transcript",
+    downloadFilePath="word_timestamps.json",
+)
+```
+
+## Account, keys, usage, and webhook configuration
+
+Agent keys can manage account settings, scoped keys, usage, and webhook endpoints.
+
+```py
+settings = client.account.get_settings()
+key = client.api_keys.create(
+    label="Backend worker",
+    scopes=["projects:read", "projects:write", "generations:read", "generations:write", "artifacts:read"],
+)
+usage = client.usage.summary(apiKeyId=key.keyId)
+webhook = client.webhooks.configure(
+    mode="live",
+    url="https://example.com/webhooks/diffio",
+    eventTypes=["generation.completed", "generation.failed"],
+    apiKeyId=key.keyId,
+)
+```
+
 ## List projects
 
 ```py

{diffio-0.1.6 → diffio-0.1.7}/pyproject.toml

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

{diffio-0.1.6 → diffio-0.1.7}/src/diffio/__init__.py

@@ -1,13 +1,19 @@
 from .client import (
+    AccountClient,
+    ApiKeysClient,
     AudioIsolationClient,
     DiffioClient,
     GenerationsClient,
     ProjectsClient,
     RequestOptions,
+    UsageClient,
     WebhooksClient,
 )
 from .errors import DiffioApiError
 from .types import (
+    AccountSettingsResponse,
+    ApiKeyResponse,
+    ApiKeysListResponse,
     AudioIsolationResult,
     CreateGenerationResponse,
     CreateProjectResponse,
@@ -22,12 +28,19 @@ from .types import (
     ModelKey,
     ProjectGenerationSummary,
     ProjectSummary,
+    UsageSummaryResponse,
+    WebhookConfigureResponse,
     WebhookEventType,
     WebhookMode,
     WebhookTestEventResponse,
 )
 
 __all__ = [
+    "AccountClient",
+    "AccountSettingsResponse",
+    "ApiKeyResponse",
+    "ApiKeysClient",
+    "ApiKeysListResponse",
     "AudioIsolationClient",
     "AudioIsolationResult",
     "CreateGenerationResponse",
@@ -48,10 +61,13 @@ __all__ = [
     "ProjectSummary",
     "ProjectsClient",
     "RequestOptions",
+    "UsageClient",
+    "UsageSummaryResponse",
+    "WebhookConfigureResponse",
     "WebhookEventType",
     "WebhookMode",
     "WebhookTestEventResponse",
     "WebhooksClient",
 ]
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"

{diffio-0.1.6 → diffio-0.1.7}/src/diffio/client.py

@@ -11,6 +11,9 @@ from svix.webhooks import Webhook
 
 from .errors import DiffioApiError
 from .types import (
+    AccountSettingsResponse,
+    ApiKeyResponse,
+    ApiKeysListResponse,
     AudioIsolationResult,
     CreateGenerationResponse,
     CreateProjectResponse,
@@ -21,6 +24,8 @@ from .types import (
     ListProjectGenerationsResponse,
     ListProjectsResponse,
     ModelKey,
+    UsageSummaryResponse,
+    WebhookConfigureResponse,
     WebhookEventType,
     WebhookMode,
     WebhookTestEventResponse,
@@ -32,6 +37,8 @@ MODEL_ENDPOINTS = {
     "diffio-2": "diffio-2.0-generation",
     "diffio-2-flash": "diffio-2.0-flash-generation",
     "diffio-3": "diffio-3.0-generation",
+    "diffio-3.4": "diffio-3.4-generation",
+    "diffio-3.5": "diffio-3.5-generation",
 }
 DEFAULT_RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504]
 DEFAULT_RETRY_BACKOFF = 0.5
@@ -175,6 +182,9 @@ class DiffioClient:
         self.audio_isolation = AudioIsolationClient(self)
         self.generations = GenerationsClient(self)
         self.projects = ProjectsClient(self)
+        self.account = AccountClient(self)
+        self.api_keys = ApiKeysClient(self)
+        self.usage = UsageClient(self)
         self.webhooks = WebhooksClient(self)
 
     def __enter__(self):
@@ -575,6 +585,112 @@ class DiffioClient:
         )
         return WebhookTestEventResponse.from_dict(response)
 
+    def get_account_settings(self, *, requestOptions=None):
+        response = self._request(
+            "POST",
+            "account/settings/get",
+            json_payload={},
+            requestOptions=requestOptions,
+        )
+        return AccountSettingsResponse.from_dict(response)
+
+    def update_account_settings(self, *, billingPolicy, requestOptions=None):
+        if not isinstance(billingPolicy, dict):
+            raise ValueError("billingPolicy must be an object")
+        response = self._request(
+            "POST",
+            "account/settings/update",
+            json_payload={"billingPolicy": billingPolicy},
+            requestOptions=requestOptions,
+        )
+        return AccountSettingsResponse.from_dict(response)
+
+    def create_api_key(self, *, label, scopes, resourceBounds=None, requestOptions=None):
+        if not label:
+            raise ValueError("label is required")
+        if not isinstance(scopes, list):
+            raise ValueError("scopes must be a list")
+        response = self._request(
+            "POST",
+            "api_keys/create",
+            json_payload={
+                "label": label,
+                "scopes": scopes,
+                "resourceBounds": resourceBounds or {},
+            },
+            requestOptions=requestOptions,
+        )
+        return ApiKeyResponse.from_dict(response)
+
+    def list_api_keys(self, *, requestOptions=None):
+        response = self._request(
+            "POST",
+            "api_keys/list",
+            json_payload={},
+            requestOptions=requestOptions,
+        )
+        return ApiKeysListResponse.from_dict(response)
+
+    def rotate_api_key(self, *, keyId, requestOptions=None):
+        if not keyId:
+            raise ValueError("keyId is required")
+        response = self._request(
+            "POST",
+            "api_keys/rotate",
+            json_payload={"keyId": keyId},
+            requestOptions=requestOptions,
+        )
+        return ApiKeyResponse.from_dict(response)
+
+    def revoke_api_key(self, *, keyId, requestOptions=None):
+        if not keyId:
+            raise ValueError("keyId is required")
+        response = self._request(
+            "POST",
+            "api_keys/revoke",
+            json_payload={"keyId": keyId},
+            requestOptions=requestOptions,
+        )
+        return ApiKeyResponse.from_dict(response)
+
+    def get_usage_summary(self, *, apiKeyId=None, requestOptions=None):
+        payload = {}
+        if apiKeyId is not None:
+            payload["apiKeyId"] = apiKeyId
+        response = self._request(
+            "POST",
+            "usage/summary",
+            json_payload=payload,
+            requestOptions=requestOptions,
+        )
+        return UsageSummaryResponse.from_dict(response)
+
+    def configure_webhook(
+        self,
+        *,
+        mode,
+        url,
+        eventTypes,
+        apiKeyId=None,
+        requestOptions=None,
+    ):
+        if mode not in WebhookMode:
+            raise ValueError("mode must be test or live")
+        if not url:
+            raise ValueError("url is required")
+        if not isinstance(eventTypes, list) or not eventTypes:
+            raise ValueError("eventTypes must be a non-empty list")
+        payload = {"mode": mode, "url": url, "eventTypes": eventTypes}
+        if apiKeyId is not None:
+            payload["apiKeyId"] = apiKeyId
+        response = self._request(
+            "POST",
+            "webhooks/configure",
+            json_payload=payload,
+            requestOptions=requestOptions,
+        )
+        return WebhookConfigureResponse.from_dict(response)
+
     def restore_audio(
         self,
         *,
@@ -662,6 +778,50 @@ class DiffioClient:
             return _raise_for_error(response)
 
 
+class AccountClient:
+    def __init__(self, parent):
+        self._parent = parent
+
+    def get_settings(self, *, requestOptions=None):
+        return self._parent.get_account_settings(requestOptions=requestOptions)
+
+    def update_settings(self, *, billingPolicy, requestOptions=None):
+        return self._parent.update_account_settings(
+            billingPolicy=billingPolicy,
+            requestOptions=requestOptions,
+        )
+
+
+class ApiKeysClient:
+    def __init__(self, parent):
+        self._parent = parent
+
+    def create(self, *, label, scopes, resourceBounds=None, requestOptions=None):
+        return self._parent.create_api_key(
+            label=label,
+            scopes=scopes,
+            resourceBounds=resourceBounds,
+            requestOptions=requestOptions,
+        )
+
+    def list(self, *, requestOptions=None):
+        return self._parent.list_api_keys(requestOptions=requestOptions)
+
+    def rotate(self, *, keyId, requestOptions=None):
+        return self._parent.rotate_api_key(keyId=keyId, requestOptions=requestOptions)
+
+    def revoke(self, *, keyId, requestOptions=None):
+        return self._parent.revoke_api_key(keyId=keyId, requestOptions=requestOptions)
+
+
+class UsageClient:
+    def __init__(self, parent):
+        self._parent = parent
+
+    def summary(self, *, apiKeyId=None, requestOptions=None):
+        return self._parent.get_usage_summary(apiKeyId=apiKeyId, requestOptions=requestOptions)
+
+
 class GenerationsClient:
     def __init__(self, parent):
         self._parent = parent
@@ -852,6 +1012,23 @@ class WebhooksClient:
             requestOptions=requestOptions,
         )
 
+    def configure(
+        self,
+        *,
+        mode,
+        url,
+        eventTypes,
+        apiKeyId=None,
+        requestOptions=None,
+    ):
+        return self._parent.configure_webhook(
+            mode=mode,
+            url=url,
+            eventTypes=eventTypes,
+            apiKeyId=apiKeyId,
+            requestOptions=requestOptions,
+        )
+
     def verify_signature(
         self,
         *,
@@ -1151,9 +1328,9 @@ def _normalize_download_type(download_type):
         return None, None
     if download_type == "mp3":
         return "audio", "mp3"
-    if download_type in {"audio", "video"}:
+    if download_type in {"audio", "video", "transcript"}:
         return download_type, download_type
-    raise ValueError("downloadType must be audio, mp3, or video")
+    raise ValueError("downloadType must be audio, mp3, video, or transcript")
 
 
 def _extension_from_file_name(file_name):
@@ -1190,6 +1367,8 @@ def _extension_from_url(download_url):
 def _expected_download_extension(download):
     if download.downloadType == "audio":
         return ".mp3"
+    if download.downloadType == "transcript":
+        return ".json"
     if download.downloadType == "video":
         return (
             _extension_from_file_name(download.fileName)

{diffio-0.1.6 → diffio-0.1.7}/src/diffio/types.py

@@ -256,6 +256,119 @@ class WebhookTestEventResponse:
         )
 
 
+class AccountSettingsResponse:
+    def __init__(self, account, apiKeyId=None):
+        self.account = account
+        self.apiKeyId = apiKeyId
+
+    @classmethod
+    def from_dict(cls, data):
+        account = data.get("account")
+        if not isinstance(account, dict):
+            account = {}
+        return cls(account=account, apiKeyId=data.get("apiKeyId"))
+
+
+class ApiKeyResponse:
+    def __init__(
+        self,
+        keyId,
+        label,
+        status,
+        keyPrefix,
+        role,
+        scopes,
+        resourceBounds,
+        key=None,
+        parentKeyId=None,
+        createdAt=None,
+        rotatedAt=None,
+        revokedAt=None,
+        permissions=None,
+    ):
+        self.key = key
+        self.keyId = keyId
+        self.label = label
+        self.status = status
+        self.keyPrefix = keyPrefix
+        self.role = role
+        self.scopes = scopes
+        self.resourceBounds = resourceBounds
+        self.parentKeyId = parentKeyId
+        self.createdAt = createdAt
+        self.rotatedAt = rotatedAt
+        self.revokedAt = revokedAt
+        self.permissions = permissions
+
+    @classmethod
+    def from_dict(cls, data):
+        scopes = data.get("scopes")
+        if not isinstance(scopes, list):
+            scopes = []
+        resource_bounds = data.get("resourceBounds")
+        if not isinstance(resource_bounds, dict):
+            resource_bounds = {}
+        permissions = data.get("permissions")
+        if permissions is not None and not isinstance(permissions, dict):
+            permissions = None
+        return cls(
+            key=data.get("key"),
+            keyId=data["keyId"],
+            label=data.get("label") or "",
+            status=data.get("status") or "active",
+            keyPrefix=data.get("keyPrefix") or "",
+            role=data.get("role") or "scoped",
+            scopes=[str(scope) for scope in scopes],
+            resourceBounds=resource_bounds,
+            parentKeyId=data.get("parentKeyId"),
+            createdAt=data.get("createdAt"),
+            rotatedAt=data.get("rotatedAt"),
+            revokedAt=data.get("revokedAt"),
+            permissions=permissions,
+        )
+
+
+class ApiKeysListResponse:
+    def __init__(self, keys):
+        self.keys = keys
+
+    @classmethod
+    def from_dict(cls, data):
+        items = data.get("keys")
+        if not isinstance(items, list):
+            items = []
+        keys = [ApiKeyResponse.from_dict(item) for item in items if isinstance(item, dict)]
+        return cls(keys=keys)
+
+
+class UsageSummaryResponse:
+    def __init__(self, usage, billing):
+        self.usage = usage
+        self.billing = billing
+
+    @classmethod
+    def from_dict(cls, data):
+        usage = data.get("usage")
+        if not isinstance(usage, dict):
+            usage = {}
+        billing = data.get("billing")
+        if not isinstance(billing, dict):
+            billing = {}
+        return cls(usage=usage, billing=billing)
+
+
+class WebhookConfigureResponse:
+    def __init__(self, webhook):
+        self.webhook = webhook
+
+    @classmethod
+    def from_dict(cls, data):
+        webhook = data.get("webhook")
+        if not isinstance(webhook, dict):
+            webhook = {}
+        return cls(webhook=webhook)
+
+
 class GenerationWebhookEvent:
     def __init__(
         self,
@@ -306,8 +419,8 @@ class AudioIsolationResult:
         self.generation = generation
 
 
-ModelKey = ("diffio-2", "diffio-2-flash", "diffio-3")
-DownloadType = ("audio", "mp3", "video")
+ModelKey = ("diffio-2", "diffio-2-flash", "diffio-3", "diffio-3.4", "diffio-3.5")
+DownloadType = ("audio", "mp3", "video", "transcript")
 WebhookMode = ("test", "live")
 WebhookEventType = (
     "generation.queued",

{diffio-0.1.6 → diffio-0.1.7/src/diffio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffio
-Version: 0.1.6
+Version: 0.1.7
 Summary: Python SDK for the Diffio API.
 Author: Diffio
 License: MIT
@@ -87,7 +87,7 @@ project = client.create_project(
 
 generation = client.create_generation(
     apiProjectId=project.apiProjectId,
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
 )
 
@@ -102,7 +102,7 @@ from diffio import DiffioClient
 client = DiffioClient(apiKey="diffio_live_...")
 result = client.audio_isolation.isolate(
     filePath="sample.wav",
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
 )
 
@@ -119,7 +119,7 @@ from diffio import DiffioClient
 client = DiffioClient(apiKey="diffio_live_...")
 audio_bytes, info = client.restore_audio(
     filePath="sample.wav",
-    model="diffio-2",
+    model="diffio-3.5",
     sampling={"steps": 12, "guidance": 1.5},
     onProgress=lambda progress: print(progress.status),
 )
@@ -165,6 +165,36 @@ 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.
+
+```py
+transcript = client.generations.download(
+    generationId="gen_123",
+    apiProjectId="proj_123",
+    downloadType="transcript",
+    downloadFilePath="word_timestamps.json",
+)
+```
+
+## Account, keys, usage, and webhook configuration
+
+Agent keys can manage account settings, scoped keys, usage, and webhook endpoints.
+
+```py
+settings = client.account.get_settings()
+key = client.api_keys.create(
+    label="Backend worker",
+    scopes=["projects:read", "projects:write", "generations:read", "generations:write", "artifacts:read"],
+)
+usage = client.usage.summary(apiKeyId=key.keyId)
+webhook = client.webhooks.configure(
+    mode="live",
+    url="https://example.com/webhooks/diffio",
+    eventTypes=["generation.completed", "generation.failed"],
+    apiKeyId=key.keyId,
+)
+```
+
 ## List projects
 
 ```py

{diffio-0.1.6 → diffio-0.1.7}/tests/test_client.py

@@ -283,6 +283,34 @@ def test_audio_isolation_isolate_runs_full_flow(tmp_path: Path):
     assert calls[2][0] == "POST"
 
 
+def test_create_generation_routes_to_diffio_3_5_endpoint():
+    received = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        received["path"] = request.url.path
+        payload = json.loads(request.content.decode("utf-8"))
+        received["payload"] = payload
+        return httpx.Response(
+            200,
+            json={
+                "generationId": "gen_35",
+                "apiProjectId": "proj_35",
+                "modelKey": "diffio-3.5",
+                "status": "queued",
+            },
+        )
+
+    transport = httpx.MockTransport(handler)
+    http_client = httpx.Client(base_url="https://api.test", transport=transport)
+    client = DiffioClient(apiKey="diffio_live_test", baseUrl="https://api.test", httpClient=http_client)
+
+    response = client.create_generation(apiProjectId="proj_35", model="diffio-3.5")
+
+    assert received["path"] == "/v1/diffio-3.5-generation"
+    assert received["payload"]["apiProjectId"] == "proj_35"
+    assert response.modelKey == "diffio-3.5"
+
+
 def test_restore_audio_runs_full_flow_and_downloads(tmp_path: Path, monkeypatch):
     status_sequence = ["queued", "processing", "complete"]
 
@@ -501,6 +529,43 @@ def test_get_generation_download_payload_and_response():
     assert download.mimeType == "audio/mpeg"
 
 
+def test_get_generation_download_accepts_transcript():
+    received = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        received["path"] = request.url.path
+        payload = json.loads(request.content.decode("utf-8"))
+        received["payload"] = payload
+        return httpx.Response(
+            200,
+            json={
+                "generationId": "gen_456",
+                "apiProjectId": "proj_456",
+                "downloadType": "transcript",
+                "downloadUrl": "https://storage.test/word_timestamps.json",
+                "fileName": "word_timestamps.json",
+                "storagePath": "users/u/projects/proj_456/generations/gen_456/word_timestamps.json",
+                "bucket": "diffio_api",
+                "mimeType": "application/json",
+            },
+        )
+
+    transport = httpx.MockTransport(handler)
+    http_client = httpx.Client(base_url="https://api.test", transport=transport)
+    client = DiffioClient(apiKey="diffio_live_test", baseUrl="https://api.test", httpClient=http_client)
+
+    download = client.generations.get_download(
+        generationId="gen_456",
+        apiProjectId="proj_456",
+        downloadType="transcript",
+    )
+
+    assert received["path"] == "/v1/get_generation_download"
+    assert received["payload"]["downloadType"] == "transcript"
+    assert download.downloadType == "transcript"
+    assert download.mimeType == "application/json"
+
+
 def test_generation_download_writes_file(tmp_path: Path):
     received = {}
 
@@ -699,6 +764,80 @@ def test_webhooks_send_test_event_payload_and_response():
     assert response.eventType == "generation.completed"
 
 
+def test_account_keys_usage_and_webhook_configure_endpoints():
+    calls = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        payload = json.loads(request.content.decode("utf-8"))
+        calls.append((request.url.path, payload))
+        if request.url.path == "/v1/account/settings/get":
+            return httpx.Response(
+                200,
+                json={
+                    "apiKeyId": "agent_1",
+                    "account": {"userId": "user_1", "billingPolicy": {"type": "internalDiffio"}},
+                },
+            )
+        if request.url.path == "/v1/api_keys/create":
+            return httpx.Response(
+                200,
+                json={
+                    "key": "diffio_live_new",
+                    "keyId": "key_1",
+                    "label": "VFC worker",
+                    "status": "active",
+                    "keyPrefix": "diffio_live_",
+                    "role": "scoped",
+                    "scopes": ["projects:read", "projects:write"],
+                    "resourceBounds": {},
+                    "parentKeyId": "agent_1",
+                },
+            )
+        if request.url.path == "/v1/usage/summary":
+            return httpx.Response(
+                200,
+                json={
+                    "usage": {"apiKeyId": "key_1", "periods": []},
+                    "billing": {"billingPolicy": {"type": "internalDiffio"}},
+                },
+            )
+        if request.url.path == "/v1/webhooks/configure":
+            return httpx.Response(
+                200,
+                json={
+                    "webhook": {
+                        "apiKeyId": "key_1",
+                        "mode": "live",
+                        "endpointId": "ep_1",
+                    }
+                },
+            )
+        return httpx.Response(404, json={"error": "not found"})
+
+    transport = httpx.MockTransport(handler)
+    http_client = httpx.Client(base_url="https://api.test", transport=transport)
+    client = DiffioClient(apiKey="diffio_live_test", baseUrl="https://api.test", httpClient=http_client)
+
+    settings = client.account.get_settings()
+    key = client.api_keys.create(label="VFC worker", scopes=["projects:read", "projects:write"])
+    usage = client.usage.summary(apiKeyId="key_1")
+    webhook = client.webhooks.configure(
+        mode="live",
+        url="https://example.com/webhook",
+        eventTypes=["generation.completed"],
+        apiKeyId="key_1",
+    )
+
+    assert settings.account["billingPolicy"]["type"] == "internalDiffio"
+    assert key.key == "diffio_live_new"
+    assert usage.billing["billingPolicy"]["type"] == "internalDiffio"
+    assert webhook.webhook["endpointId"] == "ep_1"
+    assert calls[1] == (
+        "/v1/api_keys/create",
+        {"label": "VFC worker", "scopes": ["projects:read", "projects:write"], "resourceBounds": {}},
+    )
+
+
 def test_webhooks_send_test_event_rejects_invalid_type():
     transport = httpx.MockTransport(lambda request: httpx.Response(200, json={}))
     http_client = httpx.Client(base_url="https://api.test", transport=transport)

{diffio-0.1.6 → diffio-0.1.7}/tests/test_emulator_e2e.py

@@ -9,7 +9,7 @@ import httpx
 import pytest
 
 from diffio import DiffioApiError, DiffioClient
-from emulator_api_key import create_emulator_api_key
+from emulator_api_key import EmulatorApiKeyError, create_emulator_api_key
 
 EMULATOR_BASE_URL = "http://127.0.0.1:5001/diffioai/us-central1"
 FIXTURES_DIR = Path(__file__).resolve().parent / "fixtures"
@@ -33,7 +33,12 @@ def emulator_env() -> None:
 
 @pytest.fixture(scope="session")
 def emulator_api_key(emulator_env):
-    result = create_emulator_api_key()
+    try:
+        result = create_emulator_api_key()
+    except EmulatorApiKeyError as exc:
+        if "Upgrade to the Developer plan" in str(exc):
+            pytest.skip("Local emulator account cannot create API keys without the Developer plan.")
+        raise
     os.environ["DIFFIO_API_KEY"] = result.api_key
     return result