sixtydb 1.1.0__py3-none-any.whl

sixtydb/__init__.py

@@ -0,0 +1,31 @@
+"""
+60db Python SDK
+Official Python client for the 60db API
+"""
+
+from .client import SixtyDBClient
+from .music import MusicResource
+from .judge import JudgeResource, JudgeRubricsResource, JudgeRunsResource
+from .dialer import (
+    DialerResource,
+    DialerNumbersResource,
+    DialerCallsResource,
+    DialerRecordingsResource,
+    DialerBillingResource,
+    DialerWebhooksResource,
+)
+
+__version__ = "1.1.0"
+__all__ = [
+    "SixtyDBClient",
+    "MusicResource",
+    "JudgeResource",
+    "JudgeRubricsResource",
+    "JudgeRunsResource",
+    "DialerResource",
+    "DialerNumbersResource",
+    "DialerCallsResource",
+    "DialerRecordingsResource",
+    "DialerBillingResource",
+    "DialerWebhooksResource",
+]

sixtydb/client.py

@@ -0,0 +1,312 @@
+"""
+60db API Client
+"""
+
+import requests
+from typing import Optional, Dict, Any, List, Callable
+import json
+import base64
+
+from .music import MusicResource
+from .dialer import DialerResource
+from .judge import JudgeResource
+
+
+class SixtyDBClient:
+    """Official 60db API client"""
+    
+    def __init__(self, api_key: str, base_url: str = "https://api.60db.ai"):
+        """
+        Initialize the 60db client
+        
+        Args:
+            api_key: Your 60db API key
+            base_url: API base URL (default: https://api.60db.ai)
+        """
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Authorization': f'Bearer {api_key}',
+            'Content-Type': 'application/json'
+        })
+        self.music = MusicResource(self)
+        self.dialer = DialerResource(self)
+        self.judge = JudgeResource(self)
+    
+    def _request(self, method: str, endpoint: str, **kwargs) -> Any:
+        """Make HTTP request"""
+        url = f"{self.base_url}{endpoint}"
+        response = self.session.request(method, url, **kwargs)
+        response.raise_for_status()
+        
+        if kwargs.get('stream'):
+            return response
+        
+        content_type = response.headers.get('content-type', '')
+        if 'application/json' in content_type:
+            return response.json()
+        return response.content
+    
+    # TTS Methods
+    def text_to_speech(self, text: str, voice_id: Optional[str] = None, enhance: Optional[bool] = True, speed: Optional[float] = 1.0, **params) -> bytes:
+        """
+        Convert text to speech
+        
+        Args:
+            text: Text to convert
+            voice_id: Voice ID to use
+            enhance: Enable audio enhancement
+            speed: Speech speed (0.5 to 2.0)
+            **params: Additional parameters
+            
+        Returns:
+            Audio data as bytes
+        """
+        data = {'text': text, 'enhance': enhance, 'speed': speed, **params}
+        if voice_id:
+            data['voice_id'] = voice_id
+        
+        response = self._request('POST', '/tts-synthesize', json=data)
+
+        if isinstance(response, bytes):
+            return response
+
+        if isinstance(response, dict):
+            if response.get("success") and "backendResponse" in response:
+                backend = response["backendResponse"]
+
+                if isinstance(backend, dict) and backend.get("audio_base64"):
+                    return base64.b64decode(backend["audio_base64"])
+
+            raise Exception(response.get("message", "Failed to generate audio"))
+
+        raise Exception("Unexpected TTS response format")
+
+    def text_to_speech_stream(
+        self,
+        text: str,
+        on_chunk: Callable[[bytes], None],
+        voice_id: Optional[str] = None,
+        on_complete: Optional[Callable[[], None]] = None,
+        on_error: Optional[Callable[[str], None]] = None,
+        **params
+    ) -> None:
+        """
+        Stream text to speech with callbacks
+        
+        Args:
+            text: Text to convert
+            on_chunk: Callback for audio chunks
+            voice_id: Voice ID to use
+            on_complete: Callback when complete
+            on_error: Callback for errors
+            **params: Additional parameters
+        """
+        data = {'text': text, **params}
+        if voice_id:
+            data['voice_id'] = voice_id
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/tts-stream",
+                headers={'Authorization': f'Bearer {self.api_key}', 'Content-Type': 'application/json'},
+                json=data,
+                stream=True
+            )
+            response.raise_for_status()
+            
+            buffer = ""
+            for chunk in response.iter_content(chunk_size=None, decode_unicode=True):
+                if chunk:
+                    buffer += chunk
+                    lines = buffer.split('\n')
+                    buffer = lines.pop()
+                    
+                    for line in lines:
+                        if not line.strip():
+                            continue
+                        try:
+                            parsed = json.loads(line)
+                            if parsed.get('type') == 'error':
+                                if on_error:
+                                    on_error(parsed.get('message', 'Unknown error'))
+                            elif 'result' in parsed and 'audioContent' in parsed['result']:
+                                audio_bytes = base64.b64decode(parsed['result']['audioContent'])
+                                on_chunk(audio_bytes)
+                        except json.JSONDecodeError:
+                            pass
+            
+            if on_complete:
+                on_complete()
+        except Exception as e:
+            if on_error:
+                on_error(str(e))
+            raise
+    
+    # STT Methods
+    def speech_to_text(
+        self,
+        audio_file,
+        language: Optional[str] = None,
+        diarize: Optional[bool] = None,
+        context: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Transcribe audio to text.
+
+        Args:
+            audio_file: Path or file-like object for the audio to transcribe.
+            language: ISO 639-1 code, or None / "auto" to auto-detect.
+            diarize: Enable pyannote speaker diarization.
+            context: Free-form string describing the session / domain /
+                speakers / jargon. When supplied, the server runs a
+                background LLM pass and the response text is polished
+                (proper nouns, fillers removed, punctuation). Omit to skip
+                refinement.
+        """
+
+        # If string path passed, open it
+        if isinstance(audio_file, str):
+            file_obj = open(audio_file, "rb")
+            filename = audio_file.split("\\")[-1]
+        else:
+            file_obj = audio_file
+            filename = getattr(audio_file, "name", "audio.mp3")
+
+        files = {
+            "audio": (filename, file_obj, "audio/mpeg")
+        }
+
+        data = {}
+        if language:
+            data["language"] = language
+        if diarize:
+            data["diarize"] = "true"
+        if context and context.strip():
+            data["context"] = context.strip()
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}"
+        }
+
+        response = requests.post(
+            f"{self.base_url}/stt",
+            headers=headers,
+            files=files,
+            data=data
+        )
+
+        response.raise_for_status()
+        return response.json()
+
+    
+    def get_languages(self) -> List[Dict[str, Any]]:
+        """Get supported languages"""
+        return self._request('GET', '/stt/languages')
+    
+    # Voice Methods
+    def get_voices(self) -> List[Dict[str, Any]]:
+        """Get all voices"""
+        return self._request('GET', '/voices')
+    
+    def get_voice(self, voice_id: str) -> Dict[str, Any]:
+        """Get specific voice"""
+        return self._request('GET', f'/voices/{voice_id}')
+    
+    def create_voice(self, name: str, files: List, **params) -> Dict[str, Any]:
+        """Create custom voice"""
+        file_data = [('files', f) for f in files]
+        data = {'name': name, **params}
+        
+        headers = {'Authorization': f'Bearer {self.api_key}'}
+        response = requests.post(
+            f"{self.base_url}/voices",
+            headers=headers,
+            files=file_data,
+            data=data
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    def update_voice(self, voice_id: str, **params) -> Dict[str, Any]:
+        """Update voice"""
+        return self._request('PUT', f'/voices/{voice_id}', json=params)
+    
+    def delete_voice(self, voice_id: str) -> None:
+        """Delete voice"""
+        self._request('DELETE', f'/voices/{voice_id}')
+    
+    # Auth Methods
+    def sign_up(self, email: str, password: str, **params) -> Dict[str, Any]:
+        """Register new user"""
+        data = {'email': email, 'password': password, **params}
+        return self._request('POST', '/auth/signup', json=data)
+    
+    def sign_in(self, email: str, password: str) -> Dict[str, Any]:
+        """Login user"""
+        data = {'email': email, 'password': password}
+        return self._request('POST', '/auth/login', json=data)
+    
+    def get_profile(self) -> Dict[str, Any]:
+        """Get user profile"""
+        return self._request('GET', '/auth/me')
+    
+    def update_profile(self, **params) -> Dict[str, Any]:
+        """Update user profile"""
+        return self._request('PUT', '/auth/profile', json=params)
+    
+    # Workspace Methods
+    def get_workspaces(self) -> List[Dict[str, Any]]:
+        """Get all workspaces"""
+        return self._request('GET', '/workspaces')
+    
+    def create_workspace(self, name: str, **params) -> Dict[str, Any]:
+        """Create workspace"""
+        data = {'name': name, **params}
+        return self._request('POST', '/workspaces', json=data)
+    
+    # Billing Methods
+    def get_plans(self) -> List[Dict[str, Any]]:
+        """Get available plans"""
+        return self._request('GET', '/plans')
+    
+    def get_current_plan(self) -> Dict[str, Any]:
+        """Get current subscription"""
+        return self._request('GET', '/billing/current-plan')
+    
+    def subscribe(self, plan_id: str) -> Dict[str, Any]:
+        """Subscribe to plan"""
+        return self._request('POST', '/billing/subscribe', json={'plan_id': plan_id})
+    
+    # Analytics
+    def get_usage(self) -> Dict[str, Any]:
+        """Get usage statistics"""
+        return self._request('GET', '/analytics/usage')
+    
+    # API Keys
+    def get_api_keys(self) -> List[Dict[str, Any]]:
+        """Get all API keys"""
+        return self._request('GET', '/developer/api')
+    
+    def create_api_key(self, name: str) -> Dict[str, Any]:
+        """Create API key"""
+        return self._request('POST', '/developer/api', json={'name': name})
+    
+    def delete_api_key(self, key_id: str) -> None:
+        """Delete API key"""
+        self._request('DELETE', f'/developer/api/{key_id}')
+    
+    # Webhooks
+    def get_webhooks(self) -> List[Dict[str, Any]]:
+        """Get all webhooks"""
+        return self._request('GET', '/webhooks')
+    
+    def create_webhook(self, url: str, events: List[str], **params) -> Dict[str, Any]:
+        """Create webhook"""
+        data = {'url': url, 'events': events, **params}
+        return self._request('POST', '/webhooks', json=data)
+    
+    def delete_webhook(self, webhook_id: str) -> None:
+        """Delete webhook"""
+        self._request('DELETE', f'/webhooks/{webhook_id}')

sixtydb/dialer.py

@@ -0,0 +1,238 @@
+"""
+Dialer resource for the 60db API.
+
+Not free: a number costs $6.00/month, calls cost $0.003/min. Most calls
+need a finished trunk setup and approved KYC, both done in the dashboard.
+
+`calls.reserve()` does NOT dial. It reserves and authorizes a call id
+before a SIP client (softphone/PBX) sends its SIP INVITE.
+"""
+
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+
+
+class DialerNumbersResource:
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+
+    def search(self) -> Dict[str, Any]:
+        """Search available numbers in the shared pool (no filters)."""
+        return self._client._request("GET", "/dialer/pool", timeout=60)
+
+    def buy(self, number: Optional[str] = None, **params: Any) -> Dict[str, Any]:
+        """
+        Buy a number. Charges $6.00 now, then $6.00/month.
+
+        Requires approved dialer KYC, completed inside the 60db app (not
+        exposed by this SDK) — otherwise returns 403 DIALER_KYC_REQUIRED,
+        DIALER_KYC_PENDING or DIALER_KYC_REJECTED.
+
+        Args:
+            number: Specific E.164 number, or None for the next available one.
+            **params: assign_for ("sip"|"indian_number"), outbound_trunk_id,
+                inbound_trunk_id, channel_limit.
+        """
+        body: Dict[str, Any] = {**params}
+        if number is not None:
+            body["number"] = number
+        return self._client._request(
+            "POST", "/dialer/pool/allocate", json=body, timeout=60
+        )
+
+    def list(self) -> Dict[str, Any]:
+        """List numbers owned by the workspace."""
+        return self._client._request("GET", "/dialer/numbers", timeout=60)
+
+    def release(self, e164: str) -> Dict[str, Any]:
+        """Release a number, cancel its monthly rental."""
+        return self._client._request(
+            "DELETE", f"/dialer/numbers/{quote(e164, safe='')}", timeout=60
+        )
+
+    def set_caller_id(self, e164: str) -> Dict[str, Any]:
+        """Set the default caller id for outbound calls."""
+        return self._client._request(
+            "PUT", "/dialer/caller-id", json={"caller_id": e164}, timeout=60
+        )
+
+
+class DialerCallsResource:
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+
+    def list(
+        self, limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """Call history (GET /dialer/logs). limit: 1-200, offset."""
+        params: Dict[str, Any] = {}
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+        return self._client._request("GET", "/dialer/logs", params=params, timeout=60)
+
+    def get(self, call_id: str) -> Dict[str, Any]:
+        """Get one call by id."""
+        return self._client._request(
+            "GET", f"/dialer/calls/{quote(call_id, safe='')}", timeout=60
+        )
+
+    def live(self) -> Dict[str, Any]:
+        """In-flight calls and recent CDRs."""
+        return self._client._request("GET", "/dialer/live", timeout=60)
+
+    def line_status(self) -> Dict[str, Any]:
+        """Carrier line status."""
+        return self._client._request("GET", "/dialer/calls/line-status", timeout=60)
+
+    def reserve(
+        self,
+        to: str,
+        from_number: str,
+        sip_call_id: str,
+        direction: str = "outbound",
+    ) -> Dict[str, Any]:
+        """
+        Reserve and authorize a call id. Does NOT dial.
+
+        The call is placed by a SIP client (softphone/PBX) registered with
+        the workspace's SIP credentials from the dashboard; this only
+        pre-authorizes the call id before the client sends its SIP INVITE.
+        """
+        body = {
+            "to": to,
+            "from": from_number,
+            "sip_call_id": sip_call_id,
+            "direction": direction,
+        }
+        return self._client._request("POST", "/dialer/calls", json=body, timeout=60)
+
+
+class DialerRecordingsResource:
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """List recordings. direction, status, e164, limit (1-200), offset."""
+        return self._client._request(
+            "GET", "/dialer/recordings", params=params, timeout=60
+        )
+
+    def playback_url(self, recording_id: str) -> Dict[str, Any]:
+        """Get a short-lived (~5 min) playback URL."""
+        return self._client._request(
+            "POST",
+            f"/dialer/recordings/{quote(recording_id, safe='')}/playback-url",
+            timeout=60,
+        )
+
+    def transcript(self, recording_id: str) -> Dict[str, Any]:
+        """Get (or generate) a recording's transcript."""
+        return self._client._request(
+            "POST",
+            f"/dialer/recordings/{quote(recording_id, safe='')}/transcript",
+            timeout=60,
+        )
+
+    def delete(self, recording_id: str) -> Dict[str, Any]:
+        """Queue a recording for deletion."""
+        return self._client._request(
+            "DELETE", f"/dialer/recordings/{quote(recording_id, safe='')}", timeout=60
+        )
+
+    def set_enabled(self, enabled: bool) -> Dict[str, Any]:
+        """Turn call recording on/off for outbound calls."""
+        return self._client._request(
+            "PUT", "/dialer/recording", json={"enabled": enabled}, timeout=60
+        )
+
+
+class DialerBillingResource:
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+
+    def subscriptions(self) -> Dict[str, Any]:
+        """List per-number subscriptions."""
+        return self._client._request("GET", "/dialer/subscriptions", timeout=60)
+
+    def usage(self, limit: Optional[int] = None) -> Dict[str, Any]:
+        """Balance and recent dialer charges. limit: 1-200 (default 50)."""
+        params: Dict[str, Any] = {}
+        if limit is not None:
+            params["limit"] = limit
+        return self._client._request(
+            "GET", "/dialer/usage", params=params, timeout=60
+        )
+
+
+class DialerWebhooksResource:
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+
+    def list(self) -> Dict[str, Any]:
+        """List webhooks, health and available event types."""
+        return self._client._request("GET", "/dialer/webhooks", timeout=60)
+
+    def create(self, **params: Any) -> Dict[str, Any]:
+        """
+        Create a webhook.
+
+        Required: name, url (https), event_types (non-empty list).
+        Optional: description, status, timeout_ms, rate_limit_per_minute,
+        max_attempts, max_event_age_seconds.
+
+        The response includes `signing_secret` once; store it.
+        """
+        return self._client._request("POST", "/dialer/webhooks", json=params, timeout=60)
+
+    def update(self, webhook_id: str, **params: Any) -> Dict[str, Any]:
+        """Partially update a webhook."""
+        return self._client._request(
+            "PATCH",
+            f"/dialer/webhooks/{quote(webhook_id, safe='')}",
+            json=params,
+            timeout=60,
+        )
+
+    def delete(self, webhook_id: str) -> Dict[str, Any]:
+        """Disable a webhook endpoint."""
+        return self._client._request(
+            "DELETE", f"/dialer/webhooks/{quote(webhook_id, safe='')}", timeout=60
+        )
+
+    def rotate_secret(self, webhook_id: str) -> Dict[str, Any]:
+        """Rotate the signing secret. Returns the new secret once."""
+        return self._client._request(
+            "POST",
+            f"/dialer/webhooks/{quote(webhook_id, safe='')}/rotate-secret",
+            timeout=60,
+        )
+
+    def test(self, webhook_id: str) -> Dict[str, Any]:
+        """Send a test event to the webhook."""
+        return self._client._request(
+            "POST", f"/dialer/webhooks/{quote(webhook_id, safe='')}/test", timeout=60
+        )
+
+    def deliveries(self, webhook_id: str) -> Dict[str, Any]:
+        """List recent delivery attempts."""
+        return self._client._request(
+            "GET", f"/dialer/webhooks/{quote(webhook_id, safe='')}/deliveries", timeout=60
+        )
+
+
+class DialerResource:
+    """Dialer endpoints, available at `client.dialer`."""
+
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+        self.numbers = DialerNumbersResource(client)
+        self.calls = DialerCallsResource(client)
+        self.recordings = DialerRecordingsResource(client)
+        self.billing = DialerBillingResource(client)
+        self.webhooks = DialerWebhooksResource(client)
+
+    def status(self) -> Dict[str, Any]:
+        """Dialer provisioning status for the workspace."""
+        return self._client._request("GET", "/dialer/status", timeout=60)

sixtydb/judge.py

@@ -0,0 +1,214 @@
+"""
+Judge resource for the 60db API.
+
+Ask a pinned classifier a question about your content. It never generates
+text: every answer is a probability distribution over an answer space you
+defined, which is what makes results comparable and sortable in a way prose
+never is.
+
+Two shapes:
+  * evaluate() — a rubric of up to 32 questions asked about one shared
+    `state` (a transcript, a ticket, a generated answer).
+  * extract()  — one conversational turn labelled with an intent and an
+    operation, plus entity spans as Unicode code-point offsets.
+
+Billed per input token. The upstream re-encodes the shared state once per
+question, so a 10-question rubric costs ten times the transcript — keep
+rubrics tight on long content.
+"""
+
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+
+
+class JudgeRubricsResource:
+    """Saved rubrics — build once, re-run by id. `client.judge.rubrics`."""
+
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+
+    def list(self) -> Any:
+        """Your own rubrics plus every rubric shared with the workspace."""
+        return self._client._request("GET", "/judge/rubrics")["data"]
+
+    def create(
+        self,
+        name: str,
+        questions: Dict[str, Any],
+        description: Optional[str] = None,
+        model: Optional[str] = None,
+        shared: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Save a rubric.
+
+        Args:
+            name: Unique per workspace.
+            questions: Map of answer key -> question. Each question is
+                {"type": "choice"|"score"|"noul", "instructions": ..., "criteria": ...}.
+            shared: Publish to the whole workspace. Owner/admin only.
+        """
+        body: Dict[str, Any] = {"name": name, "questions": questions, "shared": shared}
+        if description is not None:
+            body["description"] = description
+        if model is not None:
+            body["model"] = model
+        return self._client._request("POST", "/judge/rubrics", json=body)["data"]
+
+    def get(self, rubric_id: str) -> Dict[str, Any]:
+        return self._client._request("GET", f"/judge/rubrics/{quote(rubric_id)}")["data"]
+
+    def update(self, rubric_id: str, **params: Any) -> Dict[str, Any]:
+        """Patch only the fields you pass — the rest are left alone."""
+        return self._client._request("PATCH", f"/judge/rubrics/{quote(rubric_id)}", json=params)["data"]
+
+    def delete(self, rubric_id: str) -> None:
+        """Soft delete. Past runs keep their link, so history stays readable."""
+        self._client._request("DELETE", f"/judge/rubrics/{quote(rubric_id)}")
+
+
+class JudgeRunsResource:
+    """Run history and the review queue. `client.judge.runs`."""
+
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+
+    def list(
+        self,
+        limit: int = 25,
+        offset: int = 0,
+        kind: Optional[str] = None,
+        rubric_id: Optional[str] = None,
+        needs_review: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Saved runs, newest first.
+
+        Args:
+            kind: "evaluate" or "extract".
+            needs_review: Only runs the judge was under 85% sure about —
+                the upstream's own escalation line, and the queue worth a
+                person's attention.
+
+        Returns:
+            {"runs": [...], "pagination": {...}}
+        """
+        params: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if kind:
+            params["kind"] = kind
+        if rubric_id:
+            params["rubric_id"] = rubric_id
+        if needs_review:
+            params["needs_review"] = "true"
+        body = self._client._request("GET", "/judge/evaluations", params=params)
+        return {"runs": body["data"], "pagination": body.get("pagination", {})}
+
+    def get(self, run_id: str) -> Dict[str, Any]:
+        """One run including exactly what was sent and what came back."""
+        return self._client._request("GET", f"/judge/evaluations/{quote(run_id)}")["data"]
+
+    def delete(self, run_id: str) -> None:
+        self._client._request("DELETE", f"/judge/evaluations/{quote(run_id)}")
+
+
+class JudgeResource:
+    """Judge endpoints, available at `client.judge`."""
+
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+        self.rubrics = JudgeRubricsResource(client)
+        self.runs = JudgeRunsResource(client)
+
+    def evaluate(
+        self,
+        state: Any,
+        questions: Optional[Dict[str, Any]] = None,
+        rubric_id: Optional[str] = None,
+        model: Optional[str] = None,
+        save: bool = True,
+        label: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Run a rubric over content.
+
+        Args:
+            state: What every question is asked about — text, or any JSON
+                structure. Each question sees this and nothing else.
+            questions: Inline rubric. Pass this OR rubric_id, never both.
+            rubric_id: Run a saved rubric instead.
+            save: False bills the run but keeps it out of history.
+
+        Returns:
+            {"answers": {...}, "summary": {...}, "min_confidence": float|None,
+             "usage": {...}, "credits_charged": float, ...}
+
+        Raises:
+            requests.HTTPError: 400 invalid rubric, 402 out of credits,
+                429 judge busy, 503 unavailable. A failed run is refunded
+                automatically — nothing is charged for an answer you did
+                not get.
+        """
+        body: Dict[str, Any] = {"state": state}
+        if questions is not None:
+            body["questions"] = questions
+        if rubric_id is not None:
+            body["rubric_id"] = rubric_id
+        if model is not None:
+            body["model"] = model
+        if label is not None:
+            body["label"] = label
+        if not save:
+            body["save"] = False
+        return self._client._request("POST", "/judge/evaluate", json=body)["data"]
+
+    def extract(
+        self,
+        text: str,
+        schema: Dict[str, Any],
+        profile: Optional[str] = None,
+        budget_ms: Optional[int] = None,
+        save: bool = True,
+        label: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Classify one conversational turn and pull its entity spans.
+
+        Args:
+            text: The turn. Max 2,048 Unicode code points.
+            schema: {"intents": {...}, "operations": {...}, "entities": {...},
+                and optionally "responsePaths": {...}}. Each is a map of label
+                name -> description; the description is what the model reads.
+                Supplying responsePaths selects the v2 model.
+            profile: "generic" (default) or "medical".
+
+        Note:
+            Entity `start`/`end` are Unicode CODE POINT offsets, not Python
+            string indices for astral characters. Slice with
+            ``list(text)[start:end]`` if the turn may contain emoji.
+        """
+        body: Dict[str, Any] = {"text": text, "schema": schema}
+        if profile is not None:
+            body["profile"] = profile
+        if budget_ms is not None:
+            body["budget_ms"] = budget_ms
+        if label is not None:
+            body["label"] = label
+        if not save:
+            body["save"] = False
+        return self._client._request("POST", "/judge/extract", json=body)["data"]
+
+    def models(self) -> Dict[str, Any]:
+        """Model names evaluate() accepts. Authoritative — do not hardcode."""
+        return self._client._request("GET", "/judge/models")["data"]
+
+    def usage(self, period: str = "current_month") -> Dict[str, Any]:
+        """Net JUDGE_* spend and saved-run counts.
+
+        Args:
+            period: "current_month", "last_30_days" or "all_time".
+        """
+        return self._client._request("GET", "/judge/usage", params={"period": period})["data"]
+
+    def health(self) -> Dict[str, Any]:
+        """Upstream readiness, model revisions, and which upstream is in use."""
+        return self._client._request("GET", "/judge/health")["data"]

sixtydb/music.py

@@ -0,0 +1,180 @@
+"""
+Music (Songs) resource for the 60db API.
+
+Free during beta. Each create() call makes 1 song; only one generation
+runs at a time per workspace (a second create while one is running
+returns HTTP 429).
+"""
+
+import os
+import time
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+
+
+class MusicResource:
+    """Music (song generation) endpoints, available at `client.music`."""
+
+    def __init__(self, client: "Any") -> None:
+        self._client = client
+
+    def create(
+        self,
+        prompt: str,
+        lyrics_file: Optional[Any] = None,
+        **params: Any,
+    ) -> Dict[str, Any]:
+        """
+        Create a song (async, returns immediately with a "submitted" song).
+
+        Args:
+            prompt: Style (advanced mode) or description (simple mode). Required.
+            lyrics_file: Optional path or file-like object for a .txt lyrics
+                upload (sent as multipart, replaces `lyrics`).
+            **params: mode, lyrics, lyrics_prompt, instrumental, vocal_gender,
+                voice_id, negative_tags, tags, target_duration, seed (string),
+                title.
+        """
+        data: Dict[str, Any] = {"prompt": prompt, **params}
+
+        if lyrics_file is not None:
+            opened = False
+            if isinstance(lyrics_file, str):
+                file_obj = open(lyrics_file, "rb")
+                filename = os.path.basename(lyrics_file)
+                opened = True
+            else:
+                file_obj = lyrics_file
+                filename = getattr(lyrics_file, "name", "lyrics.txt")
+
+            try:
+                files = {"lyrics_file": (filename, file_obj, "text/plain")}
+                # Multipart requests must not send the session's default
+                # JSON content-type header.
+                headers = {"Authorization": f"Bearer {self._client.api_key}"}
+                import requests
+
+                def _stringify(v: Any) -> str:
+                    if isinstance(v, bool):
+                        return "true" if v else "false"
+                    return str(v)
+
+                response = requests.post(
+                    f"{self._client.base_url}/songs",
+                    headers=headers,
+                    data={k: _stringify(v) for k, v in data.items() if v is not None},
+                    files=files,
+                    timeout=60,
+                )
+                response.raise_for_status()
+                return response.json()
+            finally:
+                if opened:
+                    file_obj.close()
+
+        return self._client._request("POST", "/songs", json=data, timeout=60)
+
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """List songs (paged, newest first). limit, offset, q, status, type, liked, sort."""
+        return self._client._request("GET", "/songs", params=params, timeout=60)
+
+    def get(self, song_id: str) -> Dict[str, Any]:
+        """Get one song (SongDetail, includes lyrics)."""
+        return self._client._request(
+            "GET", f"/songs/{quote(song_id, safe='')}", timeout=60
+        )
+
+    def update(
+        self,
+        song_id: str,
+        liked: Optional[bool] = None,
+        played: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """Update flags on a song. At least one of liked/played is required."""
+        body: Dict[str, Any] = {}
+        if liked is not None:
+            body["liked"] = liked
+        if played is not None:
+            body["played"] = played
+        return self._client._request(
+            "PATCH", f"/songs/{quote(song_id, safe='')}", json=body, timeout=60
+        )
+
+    def delete(self, song_id: str) -> Dict[str, Any]:
+        """Move a song to trash (soft delete)."""
+        return self._client._request(
+            "DELETE", f"/songs/{quote(song_id, safe='')}", timeout=60
+        )
+
+    def download(self, song_id: str) -> bytes:
+        """Download the MP3 file for a song. Returns raw bytes."""
+        result = self._client._request(
+            "GET", f"/songs/{quote(song_id, safe='')}/download", timeout=120
+        )
+        if isinstance(result, bytes):
+            return result
+        raise Exception("Expected binary audio response for song download")
+
+    def wait_for_completion(
+        self, song_id: str, interval: float = 4, timeout: float = 600
+    ) -> Dict[str, Any]:
+        """
+        Poll GET /songs/{id} until status is "succeeded" or "failed".
+
+        Returns the unwrapped song object. Raises TimeoutError on timeout.
+        """
+        started_at = time.time()
+        while True:
+            response = self.get(song_id)
+            song = response.get("data", response) if isinstance(response, dict) else response
+            status = song.get("status") if isinstance(song, dict) else None
+            if status in ("succeeded", "failed"):
+                return song
+            if time.time() - started_at >= timeout:
+                raise TimeoutError(f"Timed out waiting for song {song_id} to complete")
+            time.sleep(interval)
+
+    def list_voices(self) -> Dict[str, Any]:
+        """List voices usable for song creation: `{catalog, mine}`."""
+        return self._client._request("GET", "/songs/voices", timeout=60)
+
+    def create_voice(self, name: str, file: Any) -> Dict[str, Any]:
+        """
+        Save a voice from an audio clip (multipart).
+
+        Args:
+            name: Voice name (<=200 chars).
+            file: Path or file-like object for the reference audio
+                (wav/flac/mp3/m4a/ogg, 3-30s, <=10MB).
+        """
+        opened = False
+        if isinstance(file, str):
+            file_obj = open(file, "rb")
+            filename = os.path.basename(file)
+            opened = True
+        else:
+            file_obj = file
+            filename = getattr(file, "name", "voice.wav")
+
+        try:
+            import requests
+
+            files = {"voice_reference": (filename, file_obj, "audio/wav")}
+            data = {"name": name, "consent": "true"}
+            headers = {"Authorization": f"Bearer {self._client.api_key}"}
+            response = requests.post(
+                f"{self._client.base_url}/songs/voices",
+                headers=headers,
+                data=data,
+                files=files,
+                timeout=60,
+            )
+            response.raise_for_status()
+            return response.json()
+        finally:
+            if opened:
+                file_obj.close()
+
+    def health(self) -> Dict[str, Any]:
+        """Song generation service status: `{ready, status}`."""
+        return self._client._request("GET", "/songs/health", timeout=60)

sixtydb-1.1.0.dist-info/METADATA

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: sixtydb
+Version: 1.1.0
+Summary: Official 60db SDK for Python
+Author: 60db
+License: MIT
+Keywords: 60db,tts,stt,voice,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: typing-extensions>=4.0.0
+
+# 60db
+
+Official 60db SDK for Python
+
+## Installation
+
+```bash
+pip install sixtydb
+```
+
+## Quick Start
+
+```python
+from sixtydb import SixtyDBClient
+
+
+def fetch_and_display_voices(client: SixtyDBClient) -> str:
+    """
+    Fetch all available voices and print their details.
+
+    Returns:
+        str: Selected voice_id
+    """
+    try:
+        response = client.get_voices()
+    except Exception as exc:
+        print("Error fetching voices:", exc)
+        raise
+
+    if not response.get("success"):
+        raise Exception(response.get("message"))
+
+    voices = response["data"]["built_in_voices"]
+
+    if not voices:
+        raise Exception("No voices available.")
+
+    print("\nAvailable Voices:\n" + "-" * 40)
+
+    for voice in voices:
+        print(
+            f"Name: {voice.get('name')} | "
+            f"Voice ID: {voice.get('voice_id')} | "
+            f"Language: {voice.get('language_name')} | "
+            f"Gender: {voice.get('gender')}"
+        )
+
+    return voices[0]["voice_id"]
+
+
+def generate_speech(client: SixtyDBClient, voice_id: str) -> None:
+    """
+    Generate speech and save to file.
+    """
+    try:
+        audio = client.text_to_speech(
+            text="Hello, world!",
+            voice_id=voice_id,
+            speed=1.0
+        )
+
+        with open("output.mp3", "wb") as file:
+            file.write(audio)
+
+        print("\nAudio saved to output.mp3")
+
+    except Exception as exc:
+        print("Error generating speech:", exc)
+        raise
+
+
+def main() -> None:
+    try:
+        client = SixtyDBClient("your-api-key")
+    except Exception as exc:
+        print("Error creating client:", exc)
+        return
+
+    try:
+        voice_id = fetch_and_display_voices(client)
+        generate_speech(client, voice_id)
+    except Exception as exc:
+        print("Operation failed:", exc)
+
+
+if __name__ == "__main__":
+    main()
+```
+
+---
+
+## API Methods
+
+### Text-to-Speech
+- `text_to_speech(text, voice_id=None, **params)` – Convert text to speech
+
+### Speech-to-Text
+- `speech_to_text(audio_file, language=None)` – Transcribe audio
+- `get_languages()` – Get supported languages
+
+### Voices
+- `get_voices()` – List all voices
+
+### Music
+Free during beta (no credit check, nothing charged). Each `create()` call
+makes **1 song**, and only **one generation runs at a time per workspace**
+(a second `create()` while one is running returns 429). A song takes about
+1.5-2.5 minutes.
+- `music.create(prompt, lyrics_file=None, **params)` – Create a song (async)
+- `music.list(**params)` – List songs (limit, offset, q, status, type, liked, sort)
+- `music.get(song_id)` – Get a song (includes lyrics)
+- `music.update(song_id, liked=None, played=None)` – Update flags
+- `music.delete(song_id)` – Move a song to trash
+- `music.download(song_id)` – Download the MP3 (bytes)
+- `music.wait_for_completion(song_id, interval=4, timeout=600)` – Poll until succeeded/failed
+- `music.list_voices()` – List catalog + saved voices
+- `music.create_voice(name, file)` – Save a voice from an audio clip
+- `music.health()` – Song service status
+
+### Judge
+
+Scores content against a rubric you define, and parses conversational turns.
+A classifier, not a generator — answers are probability distributions over
+your own options.
+
+```python
+run = client.judge.evaluate(
+    state=call_transcript,
+    questions={
+        "tone": {"type": "choice",
+                 "criteria": {"professional": "Calm", "dismissive": "Brushes off",
+                              "unknown": "Not clear"}},        # always add an escape hatch
+        "satisfaction": {"type": "score", "criteria": ["Angry", "Neutral", "Happy"]},
+        "resolved": {"type": "noul"},
+    },
+)
+run["answers"]["tone"]["choice"]           # 'dismissive'
+run["answers"]["satisfaction"]["score"]    # 1.87 — weighted, not an index
+run["answers"]["resolved"]["noul"]         # 0.28 — probability of true, not a confidence
+run["min_confidence"]                      # under 0.85 → send to a human
+
+rubric = client.judge.rubrics.create(name="Call QA", questions=questions)
+client.judge.evaluate(state=transcript, rubric_id=rubric["id"])
+
+turn = client.judge.extract(
+    text="move my 10am appointment to friday",
+    schema={"intents": {"booking": "Wants to change a booking"},
+            "operations": {"reschedule": "Move it"},
+            "entities": {"date": "A calendar date"}},
+)
+turn["intent"]["label"]   # 'booking'
+turn["entities"]          # [{'label': 'date', 'text': 'friday', 'start': 28, 'end': 34, ...}]
+
+client.judge.runs.list(needs_review=True)   # the low-confidence review queue
+client.judge.models()                       # authoritative model list
+client.judge.usage("current_month")         # spend and run counts
+```
+
+**Entity offsets are Unicode code points** — slice `list(text)[start:end]`,
+not `text[start:end]`, or an emoji earlier in the turn shifts every span.
+
+**Pricing:** per input token; the shared state is re-encoded once per
+question. Context is 8K tokens **per question**. Failed runs are refunded.
+
+### Dialer
+Not free: a number costs **$6.00/month**, calls cost **$0.003/min**. Most
+calls need a finished trunk setup (dashboard) and approved dialer KYC
+(also done in the dashboard, not exposed by this SDK). `calls.reserve()`
+does **not** dial — it only pre-authorizes a call id for a SIP client
+(softphone/PBX) to use.
+- `dialer.status()` – Provisioning status
+- `dialer.numbers.search()` / `.buy(number=None, **params)` / `.list()` / `.release(e164)` / `.set_caller_id(e164)` – `buy()` requires approved KYC done in the 60db app, otherwise 403 `DIALER_KYC_REQUIRED`/`DIALER_KYC_PENDING`/`DIALER_KYC_REJECTED`; charges $6.00 now, then $6.00/month
+- `dialer.calls.list(limit=None, offset=None)` / `.get(call_id)` / `.live()` / `.line_status()` / `.reserve(to, from_number, sip_call_id, direction="outbound")` – `reserve()` does not dial
+- `dialer.recordings.list(**params)` / `.playback_url(id)` / `.transcript(id)` / `.delete(id)` / `.set_enabled(enabled)`
+- `dialer.billing.subscriptions()` / `.usage(limit=None)`
+- `dialer.webhooks.list()` / `.create(**params)` / `.update(id, **params)` / `.delete(id)` / `.rotate_secret(id)` / `.test(id)` / `.deliveries(id)`
+
+---
+
+## Example: Speech to Text
+
+```python
+from sixtydb import SixtyDBClient
+
+client = SixtyDBClient("your-api-key")
+
+try:
+    with open("output.mp3", "rb") as file:
+        result = client.speech_to_text(file, language="en")
+
+    if result.get("success"):
+        print("Transcription:", result["data"]["text"])
+    else:
+        print("STT Error:", result.get("message"))
+
+except Exception as exc:
+    print("Error during transcription:", exc)
+```
+
+---
+
+## License
+
+MIT

sixtydb-1.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+sixtydb/__init__.py,sha256=dxgyfVT4AiNQx2PFh7GOiLA7n9tO5sqmvUHqEolCf7g,709
+sixtydb/client.py,sha256=YqyYQLDIjEHr3AjrDlexuDdcatAWhyG4eji6ClpIoe0,10780
+sixtydb/dialer.py,sha256=Nadla0LijLUGIgqsjhcakNXpOq4_b9ig3JBDA0pYgwE,8643
+sixtydb/judge.py,sha256=g9bJlEXX7aX0JQ8KOk0-KYC5lArvOqBrJNqjDNKixIA,8065
+sixtydb/music.py,sha256=bjmJCtPl3JK74Y7jUHyGcRUy2lKyqQHPQIDFJ-3DerA,6604
+sixtydb-1.1.0.dist-info/METADATA,sha256=67mJpEhMrO66auQoQve2g78zpapfeFnEHG4pTeZrbZ0,7356
+sixtydb-1.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sixtydb-1.1.0.dist-info/top_level.txt,sha256=oTqInjPZSaLsdxC7ZTMhDgJNYQmLpO8nyMbLglr7z4I,8
+sixtydb-1.1.0.dist-info/RECORD,,

sixtydb-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sixtydb-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sixtydb