rymi 1.1.0__tar.gz

rymi-1.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rymi AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rymi-1.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: rymi
+Version: 1.1.0
+Summary: The official Python REST API wrapper for Rymi.
+Author-email: Rymi AI <engineering@rymi.live>
+Project-URL: Homepage, https://rymi.live
+Project-URL: Documentation, https://rymi.live/docs
+Project-URL: Source, https://github.com/rymi-ai/rymi
+Classifier: Development Status :: 5 - Production/Stable
+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
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"
+Dynamic: license-file
+
+# Rymi Python SDK
+
+The official Python wrapper for the Rymi Voice AI REST API. Manage agents (incl. multi-language and model-stack config), phone numbers, calls, knowledge sources, evaluations, usage, and templates, plus webhook verification.
+
+Resources: `agents` · `calls` · `numbers` · `telephony` · `keys` · `billing` · `templates` · `webhooks`.
+
+## Installation
+
+```bash
+pip install rymi
+```
+
+## Quick Start
+
+```python
+import os
+from rymi import Rymi
+
+# Automatically picks up RYMI_API_KEY from environment
+client = Rymi()
+
+# Or pass explicitly
+# client = Rymi(api_key="rymi_live_...")
+
+agents = client.agents.list()
+for agent in agents["agents"]:
+    print(agent['name'])
+```

rymi-1.1.0/README.md

@@ -0,0 +1,28 @@
+# Rymi Python SDK
+
+The official Python wrapper for the Rymi Voice AI REST API. Manage agents (incl. multi-language and model-stack config), phone numbers, calls, knowledge sources, evaluations, usage, and templates, plus webhook verification.
+
+Resources: `agents` · `calls` · `numbers` · `telephony` · `keys` · `billing` · `templates` · `webhooks`.
+
+## Installation
+
+```bash
+pip install rymi
+```
+
+## Quick Start
+
+```python
+import os
+from rymi import Rymi
+
+# Automatically picks up RYMI_API_KEY from environment
+client = Rymi()
+
+# Or pass explicitly
+# client = Rymi(api_key="rymi_live_...")
+
+agents = client.agents.list()
+for agent in agents["agents"]:
+    print(agent['name'])
+```

rymi-1.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rymi"
+version = "1.1.0"
+description = "The official Python REST API wrapper for Rymi."
+readme = "README.md"
+authors = [
+    { name = "Rymi AI", email = "engineering@rymi.live" }
+]
+requires-python = ">=3.8"
+dependencies = [
+    "requests>=2.25.0"
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12"
+]
+
+[project.urls]
+Homepage = "https://rymi.live"
+Documentation = "https://rymi.live/docs"
+Source = "https://github.com/rymi-ai/rymi"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "responses>=0.23.0"
+]

rymi-1.1.0/rymi/__init__.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from .client import RymiClient, RymiError
+from .resources.agents import AgentsResource
+from .resources.calls import CallsResource
+from .resources.numbers import NumbersResource
+from .resources.telephony import TelephonyResource
+from .resources.keys import KeysResource
+from .resources.billing import BillingResource
+from .resources.templates import TemplatesResource
+from .resources.webhooks import WebhooksUtility
+
+class Rymi:
+    """The official Python SDK for the Rymi Voice API."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
+        self._client = RymiClient(api_key=api_key, base_url=base_url)
+
+        self.agents = AgentsResource(self._client)
+        self.calls = CallsResource(self._client)
+        self.numbers = NumbersResource(self._client)
+        self.telephony = TelephonyResource(self._client)
+        self.keys = KeysResource(self._client)
+        self.billing = BillingResource(self._client)
+        self.templates = TemplatesResource(self._client)
+        self.webhooks = WebhooksUtility()
+
+__all__ = ["Rymi", "RymiError"]

rymi-1.1.0/rymi/client.py

@@ -0,0 +1,76 @@
+import os
+import requests
+from typing import Any, Dict, Optional
+from urllib.parse import urlparse
+
+class RymiError(Exception):
+    """Custom exception raised for Rymi API Errors."""
+    def __init__(self, message: str, status: Optional[int] = None, code: Optional[str] = None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+
+class RymiClient:
+    """Core HTTP Client for the Rymi API."""
+    
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
+        self.api_key = api_key or os.environ.get("RYMI_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "The Rymi API Key must be set either by passing `api_key` to the client "
+                "or setting the `RYMI_API_KEY` environment variable."
+            )
+            
+        self.base_url = (base_url or "https://api.rymi.live/v1").rstrip("/")
+        
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+            "User-Agent": "rymi-python/1.0.0"
+        })
+
+    def request(self, method: str, path: str, json: Optional[Dict[str, Any]] = None, params: Optional[Dict[str, Any]] = None) -> Any:
+        url = f"{self.base_url}{path if path.startswith('/') else '/' + path}"
+        
+        try:
+            response = self.session.request(method, url, json=json, params=params)
+            
+            # Attempt to parse JSON regardless of status code to check for error details
+            data = None
+            if "application/json" in response.headers.get("Content-Type", ""):
+                try:
+                    data = response.json()
+                except ValueError:
+                    data = response.text
+            else:
+                data = response.text
+
+            if not response.ok:
+                message = response.reason
+                code = None
+                
+                if isinstance(data, dict):
+                    message = data.get("error", message)
+                    code = data.get("code")
+                elif isinstance(data, str) and data:
+                    message = data
+                    
+                raise RymiError(message, status=response.status_code, code=code)
+                
+            return data
+            
+        except requests.exceptions.RequestException as e:
+            raise RymiError(f"Network Error: {str(e)}")
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("GET", path, params=params)
+
+    def post(self, path: str, json: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("POST", path, json=json)
+
+    def put(self, path: str, json: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("PUT", path, json=json)
+        
+    def delete(self, path: str) -> Any:
+        return self.request("DELETE", path)

rymi-1.1.0/rymi/resources/agents.py

@@ -0,0 +1,159 @@
+from typing import Any, Dict, List, Optional
+from rymi.client import RymiClient
+
+class AgentsResource:
+    """Manage AI Agents."""
+    
+    def __init__(self, client: RymiClient):
+        self.client = client
+        
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """Retrieve a list of all your AI Agents."""
+        return self.client.get("/agents", params=params or None)
+        
+    def retrieve(self, agent_id: str) -> Dict[str, Any]:
+        """Retrieve a single AI Agent by its unique ID."""
+        return self.client.get(f"/agents/{agent_id}")
+        
+    def create(self, name: str, system_prompt: Optional[str] = None, voice: Optional[str] = None, language: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """Create a new AI Agent."""
+        prompt = kwargs.pop("prompt", None)
+        payload = {"name": name}
+        if system_prompt or prompt:
+            payload["system_prompt"] = system_prompt or prompt
+        if voice:
+            payload["voice"] = voice
+        if language:
+            payload["language"] = language
+        payload.update(kwargs)
+            
+        return self.client.post("/agents", json=payload)
+        
+    def update(self, agent_id: str, name: Optional[str] = None, system_prompt: Optional[str] = None, voice: Optional[str] = None, language: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """Update an existing AI Agent."""
+        prompt = kwargs.pop("prompt", None)
+        payload = {}
+        if name: payload["name"] = name
+        if system_prompt or prompt: payload["system_prompt"] = system_prompt or prompt
+        if voice: payload["voice"] = voice
+        if language: payload["language"] = language
+        payload.update(kwargs)
+            
+        return self.client.put(f"/agents/{agent_id}", json=payload)
+        
+    def delete(self, agent_id: str) -> Dict[str, Any]:
+        """Delete an AI Agent permanently."""
+        return self.client.delete(f"/agents/{agent_id}")
+
+    def llm_options(self) -> Dict[str, Any]:
+        """Retrieve model and voice catalog options."""
+        return self.client.get("/agents/llm-options")
+
+    def generate(self, prompt: str, options: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Generate a structured agent draft from a plain-English brief."""
+        payload: Dict[str, Any] = {"prompt": prompt}
+        if options:
+            payload["options"] = options
+        return self.client.post("/agents/generate", json=payload)
+
+    def list_calls(self, agent_id: str, limit: int = 50, offset: int = 0, status: Optional[str] = None) -> Dict[str, Any]:
+        """List calls made with a specific agent."""
+        params: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if status:
+            params["status"] = status
+        return self.client.get(f"/agents/{agent_id}/calls", params=params)
+
+    def clone(self, agent_id: str) -> Dict[str, Any]:
+        """Duplicate an existing agent. The copy gets ' (Copy)' appended to its name."""
+        return self.client.post(f"/agents/{agent_id}/clone", json={})
+
+    def validate_publish(self, agent_id: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """Check whether an agent is ready to go live without persisting changes."""
+        payload: Dict[str, Any] = {}
+        if agent_id:
+            payload["agent_id"] = agent_id
+        payload.update(kwargs)
+        return self.client.post("/agents/validate-publish", json=payload)
+
+    def apply_changes(self, current_config: Dict[str, Any], changes: list, mode: str = "edit", lenient: bool = False) -> Dict[str, Any]:
+        """Validate and resolve a flat key/value change-set. Does NOT persist — follow up with update()."""
+        return self.client.post("/agents/apply-changes", json={
+            "currentConfig": current_config,
+            "changes": changes,
+            "mode": mode,
+            "lenient": lenient,
+        })
+
+    def enrich_company(self, company_name: str, website_url: str) -> Dict[str, Any]:
+        """Auto-generate a company description from a website URL using AI + Google Search."""
+        return self.client.post("/agents/enrich-company", json={
+            "companyName": company_name,
+            "websiteUrl": website_url,
+        })
+
+    def preview_stack(
+        self,
+        supported_languages: List[str],
+        agent_role: Optional[str] = None,
+        language: Optional[str] = None,
+        current_provider_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Resolve the per-language model stack (STT/LLM/TTS), blockers, warnings, and
+        required role upgrades without saving. The concierge (realtime) role is not
+        supported by this endpoint."""
+        payload: Dict[str, Any] = {"supported_languages": supported_languages}
+        if agent_role:
+            payload["agent_role"] = agent_role
+        if language is not None:
+            payload["language"] = language
+        if current_provider_config is not None:
+            payload["current_provider_config"] = current_provider_config
+        return self.client.post("/agents/stack-preview", json=payload)
+
+    def list_knowledge_sources(self, agent_id: str) -> Dict[str, Any]:
+        """List the knowledge sources (RAG context) attached to an agent."""
+        return self.client.get(f"/agents/{agent_id}/knowledge-sources")
+
+    def add_knowledge_source(
+        self,
+        agent_id: str,
+        kind: str,
+        title: str,
+        text: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Add a knowledge source from raw text (kind='text') or a URL (kind='url')."""
+        payload: Dict[str, Any] = {"kind": kind, "title": title}
+        if text is not None:
+            payload["text"] = text
+        if url is not None:
+            payload["url"] = url
+        return self.client.post(f"/agents/{agent_id}/knowledge-sources", json=payload)
+
+    def delete_knowledge_source(self, agent_id: str, source_id: str) -> Dict[str, Any]:
+        """Delete a knowledge source from an agent."""
+        return self.client.delete(f"/agents/{agent_id}/knowledge-sources/{source_id}")
+
+    def list_changes(self, agent_id: str, since: Optional[str] = None) -> Dict[str, Any]:
+        """List recorded configuration changes for an agent (optionally since an ISO timestamp)."""
+        params = {"since": since} if since else None
+        return self.client.get(f"/agents/{agent_id}/changes", params=params)
+
+    def undo_change(self, agent_id: str, change_id: str) -> Dict[str, Any]:
+        """Undo a single recorded configuration change, reverting that field to its previous value."""
+        return self.client.post(f"/agents/{agent_id}/changes/{change_id}/undo", json={})
+
+    def run_evals(self, agent_id: str, mode: Optional[str] = None) -> Dict[str, Any]:
+        """Run the evaluation suite for an agent. mode='synthetic' (default) or 'live'."""
+        path = f"/agents/{agent_id}/evals/run"
+        if mode:
+            path += f"?mode={mode}"
+        return self.client.post(path, json={})
+
+    def list_eval_runs(self, agent_id: str) -> Dict[str, Any]:
+        """List previous evaluation runs for an agent."""
+        return self.client.get(f"/agents/{agent_id}/evals/runs")
+
+    def get_eval_run(self, agent_id: str, run_id: str) -> Dict[str, Any]:
+        """Retrieve a single evaluation run, including per-scenario scores."""
+        return self.client.get(f"/agents/{agent_id}/evals/runs/{run_id}")

rymi-1.1.0/rymi/resources/billing.py

@@ -0,0 +1,13 @@
+from typing import Any, Dict
+from rymi.client import RymiClient
+
+class BillingResource:
+    """Account usage. Voice balance is reported in MINUTES, not dollars."""
+
+    def __init__(self, client: RymiClient):
+        self.client = client
+
+    def usage_summary(self) -> Dict[str, Any]:
+        """Lane-aware usage summary: remaining voice-runtime minutes, Studio AI unit
+        usage, and post-call intelligence usage."""
+        return self.client.get("/billing/usage-summary")

rymi-1.1.0/rymi/resources/calls.py

@@ -0,0 +1,74 @@
+from typing import Any, Dict, List, Optional
+from rymi.client import RymiClient
+
+class CallsResource:
+    """Manage Outbound Calls."""
+    
+    def __init__(self, client: RymiClient):
+        self.client = client
+        
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """Retrieve a list of all call records."""
+        return self.client.get("/calls", params=params or None)
+
+    def active(self, **params: Any) -> Dict[str, Any]:
+        """Retrieve active in-progress calls."""
+        return self.client.get("/calls/active", params=params or None)
+        
+    def retrieve(self, call_id: str) -> Dict[str, Any]:
+        """Retrieve a single call record and transcript."""
+        return self.client.get(f"/calls/{call_id}")
+        
+    def create(
+        self,
+        agent_id: str,
+        participants: Optional[List[Dict[str, Any]]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        post_call: Optional[Dict[str, Any]] = None,
+        to: Optional[str] = None,
+        from_number: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Create a WebRTC/PSTN call using the participant-first API."""
+        if participants is None and to:
+            participants = [{
+                "transport": "pstn",
+                "identity": to,
+                "from_number": from_number
+            }]
+
+        payload = {
+            "agent_id": agent_id,
+            "participants": participants or []
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if variables:
+            payload["variables"] = variables
+        if post_call:
+            payload["post_call"] = post_call
+            
+        return self.client.post("/calls", json=payload)
+
+    def batch(self, agent_id: str, to: List[str], from_number: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """Queue a batch of outbound PSTN recipients."""
+        payload = {"agent_id": agent_id, "to": to}
+        if from_number:
+            payload["from_number"] = from_number
+        payload.update(kwargs)
+        return self.client.post("/calls/batch", json=payload)
+
+    def summary(self, call_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/calls/{call_id}/summary")
+
+    def transcript(self, call_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/calls/{call_id}/transcript")
+
+    def recording(self, call_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/calls/{call_id}/recording")
+
+    def reprocess(self, call_id: str) -> Dict[str, Any]:
+        return self.client.post(f"/calls/{call_id}/reprocess")
+
+    def queue_stats(self) -> Dict[str, Any]:
+        return self.client.get("/calls/queue/stats")

rymi-1.1.0/rymi/resources/keys.py

@@ -0,0 +1,16 @@
+from typing import Any, Dict
+from rymi.client import RymiClient
+
+class KeysResource:
+    """Read-only access to publishable (browser-safe) keys.
+
+    Creating or revoking keys mints/destroys credentials and changes standing
+    config, so those remain dashboard actions and are not exposed here.
+    """
+
+    def __init__(self, client: RymiClient):
+        self.client = client
+
+    def list_publishable(self) -> Dict[str, Any]:
+        """List publishable keys and their agent/channel scoping. Returns key prefixes only, never full secrets."""
+        return self.client.get("/keys/publishable")

rymi-1.1.0/rymi/resources/numbers.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict, Optional
+from rymi.client import RymiClient
+
+class NumbersResource:
+    """Manage already-owned BYOC phone numbers registered with Rymi."""
+    
+    def __init__(self, client: RymiClient):
+        self.client = client
+        
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """Retrieve a list of all assigned phone numbers."""
+        return self.client.get("/numbers", params=params or None)
+
+    def register(self, number: str, agent_id: Optional[str] = None) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {"number": number}
+        if agent_id is not None:
+            payload["agent_id"] = agent_id
+        return self.client.post("/numbers", json=payload)
+
+    def attach(self, number: str, agent_id: str) -> Dict[str, Any]:
+        return self.client.post(f"/numbers/{number}/attach", json={"agent_id": agent_id})
+
+    def remove(self, number: str) -> Dict[str, Any]:
+        return self.client.delete(f"/numbers/{number}")

rymi-1.1.0/rymi/resources/telephony.py

@@ -0,0 +1,20 @@
+from typing import Any, Dict
+from rymi.client import RymiClient
+
+class TelephonyResource:
+    """Inspect the connected telephony carrier.
+
+    Connecting/disconnecting a carrier requires carrier credentials and changes a
+    standing integration, so it is a dashboard action and not exposed here.
+    """
+
+    def __init__(self, client: RymiClient):
+        self.client = client
+
+    def status(self) -> Dict[str, Any]:
+        """Report whether a carrier is connected, and which provider/account."""
+        return self.client.get("/telephony/status")
+
+    def numbers(self) -> Dict[str, Any]:
+        """List numbers available on the connected telephony carrier account."""
+        return self.client.get("/telephony/numbers")

rymi-1.1.0/rymi/resources/templates.py

@@ -0,0 +1,12 @@
+from typing import Any, Dict
+from rymi.client import RymiClient
+
+class TemplatesResource:
+    """Published agent templates."""
+
+    def __init__(self, client: RymiClient):
+        self.client = client
+
+    def list(self) -> Dict[str, Any]:
+        """List published agent templates. Use a template's `defaults` as the starting config for agents.create()."""
+        return self.client.get("/agent-templates")

rymi-1.1.0/rymi/resources/webhooks.py

@@ -0,0 +1,46 @@
+import hmac
+import hashlib
+import time
+
+class WebhooksUtility:
+    """Secure Utility for Webhook Signature Verification."""
+
+    @staticmethod
+    def verify_signature(
+        payload: str,
+        signature_header: str,
+        timestamp_header: str,
+        webhook_secret: str,
+        tolerance_millis: int = 300000 # 5 minutes
+    ) -> bool:
+        """
+        Verifies that a webhook received by your backend was genuinely dispatched by Rymi.
+        
+        Rymi endpoints secure webhooks by computing an HMAC-SHA256 signature
+        of the raw JSON body concatenated with the timestamp using your Webhook Secret.
+        """
+        # 1. Check for Replay Attacks
+        try:
+            timestamp = int(timestamp_header)
+        except ValueError:
+            raise ValueError("Invalid Rymi-Timestamp header format.")
+            
+        current_time = int(time.time() * 1000)
+        if (current_time - timestamp) > tolerance_millis:
+            raise ValueError("Webhook timestamp is too old. Possible replay attack.")
+            
+        # 2. Prepare the verification string
+        signature_payload = f"{timestamp}.{payload}"
+        
+        # 3. Compute expected HMAC
+        expected_signature = hmac.new(
+            webhook_secret.encode('utf-8'),
+            signature_payload.encode('utf-8'),
+            hashlib.sha256
+        ).hexdigest()
+        
+        # 4. Secure string comparison
+        if not hmac.compare_digest(signature_header, expected_signature):
+            raise ValueError("Invalid Webhook Signature. The secret might be incorrect.")
+            
+        return True

rymi-1.1.0/rymi.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: rymi
+Version: 1.1.0
+Summary: The official Python REST API wrapper for Rymi.
+Author-email: Rymi AI <engineering@rymi.live>
+Project-URL: Homepage, https://rymi.live
+Project-URL: Documentation, https://rymi.live/docs
+Project-URL: Source, https://github.com/rymi-ai/rymi
+Classifier: Development Status :: 5 - Production/Stable
+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
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"
+Dynamic: license-file
+
+# Rymi Python SDK
+
+The official Python wrapper for the Rymi Voice AI REST API. Manage agents (incl. multi-language and model-stack config), phone numbers, calls, knowledge sources, evaluations, usage, and templates, plus webhook verification.
+
+Resources: `agents` · `calls` · `numbers` · `telephony` · `keys` · `billing` · `templates` · `webhooks`.
+
+## Installation
+
+```bash
+pip install rymi
+```
+
+## Quick Start
+
+```python
+import os
+from rymi import Rymi
+
+# Automatically picks up RYMI_API_KEY from environment
+client = Rymi()
+
+# Or pass explicitly
+# client = Rymi(api_key="rymi_live_...")
+
+agents = client.agents.list()
+for agent in agents["agents"]:
+    print(agent['name'])
+```

rymi-1.1.0/rymi.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+rymi/__init__.py
+rymi/client.py
+rymi.egg-info/PKG-INFO
+rymi.egg-info/SOURCES.txt
+rymi.egg-info/dependency_links.txt
+rymi.egg-info/requires.txt
+rymi.egg-info/top_level.txt
+rymi/resources/agents.py
+rymi/resources/billing.py
+rymi/resources/calls.py
+rymi/resources/keys.py
+rymi/resources/numbers.py
+rymi/resources/telephony.py
+rymi/resources/templates.py
+rymi/resources/webhooks.py
+tests/test_sdk.py

rymi-1.1.0/rymi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rymi-1.1.0/rymi.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.25.0
+
+[dev]
+pytest>=7.0.0
+responses>=0.23.0

rymi-1.1.0/rymi.egg-info/top_level.txt

@@ -0,0 +1 @@
+rymi

rymi-1.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rymi-1.1.0/tests/test_sdk.py

@@ -0,0 +1,78 @@
+import os
+import time
+import pytest
+import responses
+import hmac
+import hashlib
+import json
+from rymi import Rymi, RymiError
+
+@pytest.fixture
+def rymi_client():
+    os.environ["RYMI_API_KEY"] = "rymi_test_123"
+    return Rymi()
+
+@responses.activate
+def test_client_authentication(rymi_client):
+    responses.add(
+        responses.GET,
+        "https://api.rymi.live/v1/agents",
+        json={"agents": [{"id": "agent_1"}], "total": 1, "offset": 0, "limit": 50},
+        status=200
+    )
+    
+    agents = rymi_client.agents.list()
+    assert len(agents["agents"]) == 1
+    assert agents["agents"][0]["id"] == "agent_1"
+    
+    # Verify headers
+    req = responses.calls[0].request
+    assert req.headers["Authorization"] == "Bearer rymi_test_123"
+    assert req.headers["Accept"] == "application/json"
+
+@responses.activate
+def test_client_error_handling(rymi_client):
+    responses.add(
+        responses.POST,
+        "https://api.rymi.live/v1/calls",
+        json={"error": "Agent not found", "code": "not_found"},
+        status=404
+    )
+    
+    with pytest.raises(RymiError) as exc_info:
+        rymi_client.calls.create(agent_id="bad_id", to="+123", from_number="+123")
+        
+    assert "Agent not found" in str(exc_info.value)
+    assert exc_info.value.status == 404
+    assert exc_info.value.code == "not_found"
+
+def test_webhook_signature_verification(rymi_client):
+    secret = "whsec_test_secret"
+    payload = json.dumps({"type": "call.ended", "call_id": "call_123"})
+    timestamp = str(int(time.time() * 1000))
+    
+    # Generate valid signature
+    signature_payload = f"{timestamp}.{payload}"
+    signature = hmac.new(
+        secret.encode('utf-8'),
+        signature_payload.encode('utf-8'),
+        hashlib.sha256
+    ).hexdigest()
+    
+    # Should pass
+    assert rymi_client.webhooks.verify_signature(payload, signature, timestamp, secret) is True
+    
+    # Should fail bad signature
+    with pytest.raises(ValueError, match="Invalid Webhook Signature"):
+        rymi_client.webhooks.verify_signature(payload, "bad_signature", timestamp, secret)
+        
+    # Should fail replay attack
+    old_timestamp = str(int(time.time() * 1000) - 600000) # 10 mins ago
+    old_signature = hmac.new(
+        secret.encode('utf-8'),
+        f"{old_timestamp}.{payload}".encode('utf-8'),
+        hashlib.sha256
+    ).hexdigest()
+    
+    with pytest.raises(ValueError, match="Possible replay attack"):
+        rymi_client.webhooks.verify_signature(payload, old_signature, old_timestamp, secret)