Merge pull request #5 from ofspectrum/sync-sdk-v1.1.6

Sync SDK v1.1.6 from neo

Author: jlw463195395

AGENT_GUIDE.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+## 1.1.6
+
+- Added notebook media limits of 10 files, 100 MB per file, and 10 GB total.
+- Added SDK methods to list and create reusable AI authorization tags.
+- Normalized unlimited private notebook limits to `None` in public SDK token models.
+
 ## 1.1.4
 
 - Updated token documentation for Standard, Pro, and eligible Enterprise workflows.

CHANGELOG.md

@@ -85,8 +85,43 @@ token = client.tokens.update(
     token_id="token-uuid",
     public_key=verification_key,
 )
+
+# Upgrade an existing Standard token to Pro.
+# Token types can be upgraded, but not downgraded.
+token = client.tokens.update(
+    token_id="token-uuid",
+    token_type="pro",
+    public_key=verification_key,
+)
+
+# Configure how the token may be used by AI systems.
+token = client.tokens.update(
+    token_id="token-uuid",
+    ai_auth_enabled=True,
+    ai_auth_access_type="direct_use",  # or "premium_track"
+    ai_auth_price=5,
+    ai_auth_other_instructions="Attribution required",
+    ai_auth_tags=["voice", "licensed"],
+)
 ```
 
+Passing `ai_auth_price=None` clears the price. Passing `ai_auth_tags=[]` removes all AI authorization tags from the token.
+
+Reusable AI authorization tags can be listed or created separately:
+
+```python
+tags = client.tokens.list_ai_auth_tags()
+voice_tag = client.tokens.create_ai_auth_tag("Voice Clone")
+
+client.tokens.update(
+    token_id="token-uuid",
+    ai_auth_tags=[voice_tag.tag],
+)
+```
+
+Creating a tag does not attach it to a token. Pass the selected tag names to
+`tokens.create()` or `tokens.update()` to associate them with a token.
+
 Token deletion is not available via API. Tokens are consumable resources.
 
 ## Audio Watermarking
@@ -144,8 +179,9 @@ Notebook limits:
 
 | Token Type | Public Notebooks | Private Notebooks |
 |------------|------------------|-------------------|
-| `standard` | 1 | 0 |
-| `pro` | 1 | 1 |
+| `standard` | 1 | 1 |
+| `pro` | 1 | Unlimited |
+| `enterprise` | 1 | Unlimited |
 
 If the limit is reached, the SDK raises a `ValidationError` with a customer-facing message.
 
@@ -173,6 +209,9 @@ client.notebooks.upload_media(
 notebooks = client.notebooks.list(token_id=token.id)
 ```
 
+Each notebook accepts up to 10 media files. Each file may be up to 100 MB, and
+the combined media size limit is 10 GB per notebook.
+
 ## Quota Checking
 
 ```python

README.md

@@ -29,7 +29,7 @@
     print(f"Remaining: {quota.remaining}/{quota.limit}")
 """
 
-__version__ = "1.1.5"
+__version__ = "1.1.6"
 __author__ = "OfSpectrum"
 
 from .client import OfSpectrum, AsyncOfSpectrum
@@ -47,6 +47,7 @@
 )
 from .models import (
     Token,
+    AiAuthTag,
     TokenCreateParams,
     TokenUpdateParams,
     Notebook,
@@ -77,6 +78,7 @@
     "NetworkError",
     # Models
     "Token",
+    "AiAuthTag",
     "TokenCreateParams",
     "TokenUpdateParams",
     "Notebook",

ofspectrum/__init__.py

@@ -222,8 +222,8 @@ def _raise_detail_error(message: str, status_code: int):
     if message == "Private notebook limit reached for this token":
         raise ValidationError(
             message=(
-                "Private notebook limit reached for this token. Standard tokens do not support "
-                "private notebooks; Pro tokens support one private notebook."
+                "Private notebook limit reached for this token. Standard tokens support one "
+                "private notebook; Pro tokens have no private notebook limit."
             ),
             code="NotebookLimit",
             status_code=status_code or 400,

ofspectrum/exceptions.py

@@ -2,13 +2,14 @@
 OfSpectrum SDK Data Models
 """
 
-from .token import Token, TokenCreateParams, TokenUpdateParams
+from .token import AiAuthTag, Token, TokenCreateParams, TokenUpdateParams
 from .notebook import Notebook, NotebookMedia, NotebookCreateParams
 from .audio import EncodeResult, DecodeResult, StreamingEncodeResult
 from .quota import Quota, QuotaList
 
 __all__ = [
     "Token",
+    "AiAuthTag",
     "TokenCreateParams",
     "TokenUpdateParams",
     "Notebook",

ofspectrum/models/__init__.py

@@ -3,8 +3,29 @@
 """
 
 from dataclasses import dataclass, field
-from typing import Optional, Literal
-from datetime import datetime
+from typing import Any, List, Literal, Optional
+
+
+UNSET = object()
+
+
+@dataclass
+class AiAuthTag:
+    """Reusable AI authorization tag owned by the current account."""
+
+    id: str
+    tag: str
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "AiAuthTag":
+        return cls(
+            id=data["id"],
+            tag=data.get("tag", ""),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+        )
 
 
 @dataclass
@@ -16,6 +37,12 @@ class Token:
     token_type: Literal["standard", "pro", "enterprise"]
     public_key: Optional[int] = None
     enterprise_verification: bool = False
+    max_private_notes: Optional[int] = None
+    ai_auth_enabled: bool = False
+    ai_auth_access_type: Optional[Literal["direct_use", "premium_track"]] = None
+    ai_auth_price: Optional[float] = None
+    ai_auth_other_instructions: Optional[str] = None
+    ai_auth_tags: List[str] = field(default_factory=list)
     created_at: Optional[str] = None
     updated_at: Optional[str] = None
 
@@ -28,6 +55,14 @@ def from_dict(cls, data: dict) -> "Token":
             token_type=data.get("token_type", "standard"),
             public_key=data.get("public_key"),
             enterprise_verification=data.get("enterprise_verification", False),
+            max_private_notes=None
+            if data.get("max_private_notes") is None or int(data.get("max_private_notes", 0)) < 0
+            else int(data.get("max_private_notes", 0)),
+            ai_auth_enabled=data.get("ai_auth_enabled", False),
+            ai_auth_access_type=data.get("ai_auth_access_type") or None,
+            ai_auth_price=data.get("ai_auth_price"),
+            ai_auth_other_instructions=data.get("ai_auth_other_instructions") or None,
+            ai_auth_tags=list(data.get("ai_auth_tags") or []),
             created_at=data.get("created_at"),
             updated_at=data.get("updated_at"),
         )
@@ -40,6 +75,11 @@ class TokenCreateParams:
     name: str
     token_type: Literal["standard", "pro"] = "standard"
     public_key: Optional[int] = None
+    ai_auth_enabled: bool = False
+    ai_auth_access_type: Optional[Literal["direct_use", "premium_track"]] = None
+    ai_auth_price: Optional[float] = None
+    ai_auth_other_instructions: Optional[str] = None
+    ai_auth_tags: Optional[List[str]] = None
 
     def to_dict(self) -> dict:
         """Convert to API request dict"""
@@ -49,6 +89,16 @@ def to_dict(self) -> dict:
         }
         if self.public_key is not None:
             data["public_key"] = self.public_key
+        if self.ai_auth_enabled:
+            data["ai_auth_enabled"] = True
+        if self.ai_auth_access_type is not None:
+            data["ai_auth_access_type"] = self.ai_auth_access_type
+        if self.ai_auth_price is not None:
+            data["ai_auth_price"] = self.ai_auth_price
+        if self.ai_auth_other_instructions is not None:
+            data["ai_auth_other_instructions"] = self.ai_auth_other_instructions
+        if self.ai_auth_tags is not None:
+            data["ai_auth_tags"] = self.ai_auth_tags
         return data
 
 
@@ -58,7 +108,13 @@ class TokenUpdateParams:
 
     name: Optional[str] = None
     public_key: Optional[int] = None
+    token_type: Optional[Literal["standard", "pro", "enterprise"]] = None
     enterprise_verification: Optional[bool] = None
+    ai_auth_enabled: Optional[bool] = None
+    ai_auth_access_type: Optional[Literal["direct_use", "premium_track"]] = None
+    ai_auth_price: Any = UNSET
+    ai_auth_other_instructions: Optional[str] = None
+    ai_auth_tags: Optional[List[str]] = None
 
     def to_dict(self) -> dict:
         """Convert to API request dict (only non-None fields)"""
@@ -67,6 +123,18 @@ def to_dict(self) -> dict:
             data["name"] = self.name
         if self.public_key is not None:
             data["public_key"] = self.public_key
+        if self.token_type is not None:
+            data["token_type"] = self.token_type
         if self.enterprise_verification is not None:
             data["enterprise_verification"] = self.enterprise_verification
+        if self.ai_auth_enabled is not None:
+            data["ai_auth_enabled"] = self.ai_auth_enabled
+        if self.ai_auth_access_type is not None:
+            data["ai_auth_access_type"] = self.ai_auth_access_type
+        if self.ai_auth_price is not UNSET:
+            data["ai_auth_price"] = self.ai_auth_price
+        if self.ai_auth_other_instructions is not None:
+            data["ai_auth_other_instructions"] = self.ai_auth_other_instructions
+        if self.ai_auth_tags is not None:
+            data["ai_auth_tags"] = self.ai_auth_tags
         return data

ofspectrum/models/token.py

@@ -2,15 +2,37 @@
 Tokens resource for managing watermark tokens
 """
 
-from typing import List, Optional, Literal
+from typing import Any, List, Literal, Optional
 from .base import BaseResource
-from ..models.token import Token, TokenCreateParams, TokenUpdateParams
+from ..models.token import AiAuthTag, UNSET, Token, TokenCreateParams, TokenUpdateParams
 from ..exceptions import raise_for_error
 
 
 class TokensResource(BaseResource):
     """Resource for managing watermark tokens"""
 
+    def list_ai_auth_tags(self) -> List[AiAuthTag]:
+        """List reusable AI authorization tags for the current account."""
+        response = self._get("/tokens/ai-auth-tags")
+        data = response.json()
+        raise_for_error(data, response.status_code)
+
+        tags_data = data if isinstance(data, list) else data.get("data", {}).get("tags", [])
+        return [AiAuthTag.from_dict(tag) for tag in tags_data]
+
+    def create_ai_auth_tag(self, tag: str) -> AiAuthTag:
+        """Create or retrieve a reusable AI authorization tag."""
+        normalized_tag = tag.strip()
+        if not normalized_tag:
+            raise ValueError("tag must not be empty")
+
+        response = self._post("/tokens/ai-auth-tags", json={"tag": normalized_tag})
+        data = response.json()
+        raise_for_error(data, response.status_code)
+
+        tag_data = data if isinstance(data, dict) and "id" in data else data.get("data", {})
+        return AiAuthTag.from_dict(tag_data)
+
     def list(self) -> List[Token]:
         """
         List all tokens for the current user.
@@ -58,6 +80,11 @@ def create(
         name: str,
         token_type: Literal["standard", "pro"] = "standard",
         public_key: Optional[int] = None,
+        ai_auth_enabled: bool = False,
+        ai_auth_access_type: Optional[Literal["direct_use", "premium_track"]] = None,
+        ai_auth_price: Optional[float] = None,
+        ai_auth_other_instructions: Optional[str] = None,
+        ai_auth_tags: Optional[List[str]] = None,
     ) -> Token:
         """
         Create a new watermark token.
@@ -67,6 +94,11 @@ def create(
             token_type: "standard" (default) or "pro"
             public_key: Verification key when your token workflow requires one.
                         Defaults to 258 for pro tokens if not provided.
+            ai_auth_enabled: Whether AI authorization is enabled
+            ai_auth_access_type: "direct_use" or "premium_track" (optional)
+            ai_auth_price: AI authorization price; must be at least 1 when set
+            ai_auth_other_instructions: Additional AI authorization instructions
+            ai_auth_tags: Searchable AI authorization tags
 
         Returns:
             Newly created Token object
@@ -95,6 +127,11 @@ def create(
             name=name,
             token_type=token_type,
             public_key=public_key,
+            ai_auth_enabled=ai_auth_enabled,
+            ai_auth_access_type=ai_auth_access_type,
+            ai_auth_price=ai_auth_price,
+            ai_auth_other_instructions=ai_auth_other_instructions,
+            ai_auth_tags=ai_auth_tags,
         )
 
         response = self._post("/tokens/", json=params.to_dict())
@@ -111,7 +148,13 @@ def update(
         token_id: str,
         name: Optional[str] = None,
         public_key: Optional[int] = None,
+        token_type: Optional[Literal["standard", "pro", "enterprise"]] = None,
         enterprise_verification: Optional[bool] = None,
+        ai_auth_enabled: Optional[bool] = None,
+        ai_auth_access_type: Optional[Literal["direct_use", "premium_track"]] = None,
+        ai_auth_price: Any = UNSET,
+        ai_auth_other_instructions: Optional[str] = None,
+        ai_auth_tags: Optional[List[str]] = None,
     ) -> Token:
         """
         Update an existing token.
@@ -120,15 +163,27 @@ def update(
             token_id: The token UUID
             name: New name (optional)
             public_key: New verification key when your token workflow supports it (optional)
+            token_type: New token type. The API permits upgrades but rejects downgrades.
             enterprise_verification: Enterprise-only verification setting for eligible accounts (optional)
+            ai_auth_enabled: Whether AI authorization is enabled
+            ai_auth_access_type: "direct_use" or "premium_track" (optional)
+            ai_auth_price: AI authorization price, or None to clear it
+            ai_auth_other_instructions: Additional AI authorization instructions
+            ai_auth_tags: Replacement list of AI authorization tags
 
         Returns:
             Updated Token object
         """
         params = TokenUpdateParams(
             name=name,
             public_key=public_key,
+            token_type=token_type,
             enterprise_verification=enterprise_verification,
+            ai_auth_enabled=ai_auth_enabled,
+            ai_auth_access_type=ai_auth_access_type,
+            ai_auth_price=ai_auth_price,
+            ai_auth_other_instructions=ai_auth_other_instructions,
+            ai_auth_tags=ai_auth_tags,
         )
 
         update_data = params.to_dict()

ofspectrum/resources/tokens.py

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ofspectrum"
-version = "1.1.5"
+version = "1.1.6"
 description = "OfSpectrum Audio Watermarking SDK"
 readme = "README.md"
 license = {text = "MIT"}