wirexaapi 1.0.0__py3-none-any.whl

wirexaapi/__init__.py

@@ -0,0 +1,187 @@
+"""
+Wirexa API SDK - Drop-in replacement del SDK de SignalWire/Twilio.
+
+CREDENCIALES (las obtienes del dashboard):
+  space_url  = "your-space.example.com:5000"
+  project_id = "your-project-id"
+  api_token  = "your-api-token"
+
+USO:
+
+  ANTES (SignalWire original):
+    from signalwire.rest import Client
+    client = Client(project_id, api_token, signalwire_space_url=space_url)
+
+  DESPUÉS (Wirexa API):
+    from wirexaapi import Client
+    client = Client(project_id, api_token, signalwire_space_url=space_url)
+
+  El resto del código NO cambia.
+"""
+from __future__ import annotations
+
+import logging
+import requests
+from typing import Optional
+
+logger = logging.getLogger("wirexaapi.http_client")
+
+
+class _CallsResource:
+    """Imita el objeto client.calls del SDK."""
+
+    def __init__(self, base_url: str, auth: tuple):
+        self._base = base_url
+        self._auth = auth
+
+    def create(
+        self,
+        to: str,
+        from_: str,
+        url: str,
+        method: str = "POST",
+        timeout: int = 28,
+        record: bool = False,
+        status_callback: Optional[str] = None,
+        status_callback_method: str = "POST",
+        status_callback_event: Optional[list] = None,
+        recording_status_callback: Optional[str] = None,
+        recording_status_callback_method: str = "POST",
+        machine_detection: Optional[str] = None,
+        machine_detection_timeout: int = 30,
+        async_amd: bool = False,
+        async_amd_status_callback: Optional[str] = None,
+    ) -> "_CallInstance":
+        data = {
+            "To":     to,
+            "From":   from_,
+            "Url":    url,
+            "Method": method,
+            "Timeout": str(timeout),
+            "Record": "true" if record else "false",
+            "StatusCallbackMethod":          status_callback_method,
+            "RecordingStatusCallbackMethod": recording_status_callback_method,
+        }
+
+        if status_callback:
+            data["StatusCallback"] = status_callback
+
+        if status_callback_event:
+            data["StatusCallbackEvent"] = " ".join(status_callback_event)
+
+        if recording_status_callback:
+            data["RecordingStatusCallback"] = recording_status_callback
+
+        if machine_detection:
+            data["MachineDetection"] = machine_detection
+            data["MachineDetectionTimeout"] = str(machine_detection_timeout)
+
+        if async_amd:
+            data["AsyncAmd"] = "true"
+        if async_amd_status_callback:
+            data["AsyncAmdStatusCallback"] = async_amd_status_callback
+
+        endpoint = f"{self._base}/Calls.json"
+
+        logger.info("Request: POST %s", endpoint)
+        logger.info("Params: %s", data)
+
+        r = requests.post(endpoint, auth=self._auth, data=data, timeout=30)
+
+        logger.info("Response: HTTP %s", r.status_code)
+        logger.info("Response Body: %s", r.text[:500])
+
+        r.raise_for_status()
+        instance = _CallInstance(r.json())
+
+        logger.info("[calls.create] Call %s status: %s", instance.sid, instance.status)
+
+        return instance
+
+    def list(self, status: Optional[str] = None, limit: int = 50) -> list:
+        params = {"PageSize": limit}
+        if status:
+            params["Status"] = status
+        r = requests.get(f"{self._base}/Calls.json", auth=self._auth, params=params, timeout=10)
+        r.raise_for_status()
+        return [_CallInstance(c) for c in r.json().get("calls", [])]
+
+    def __call__(self, call_sid: str) -> "_CallContext":
+        return _CallContext(self._base, self._auth, call_sid)
+
+
+class _CallContext:
+    """Imita client.calls('CAxxxxx')"""
+
+    def __init__(self, base_url: str, auth: tuple, call_sid: str):
+        self._base = base_url
+        self._auth = auth
+        self._sid  = call_sid
+
+    def fetch(self) -> "_CallInstance":
+        r = requests.get(f"{self._base}/Calls/{self._sid}.json", auth=self._auth, timeout=10)
+        r.raise_for_status()
+        return _CallInstance(r.json())
+
+    def update(self, status: Optional[str] = None, url: Optional[str] = None) -> "_CallInstance":
+        data = {}
+        if status:
+            data["Status"] = status
+        if url:
+            data["Url"] = url
+        r = requests.post(f"{self._base}/Calls/{self._sid}.json", auth=self._auth, data=data, timeout=10)
+        r.raise_for_status()
+        return _CallInstance(r.json())
+
+
+class _CallInstance:
+    """Objeto retornado por calls.create() / fetch()."""
+
+    def __init__(self, data: dict):
+        self._data       = data
+        self.sid         = data.get("sid", "")
+        self.status      = data.get("status", "")
+        self.to          = data.get("to", "")
+        self.from_       = data.get("from", "")
+        self.direction   = data.get("direction", "")
+        self.duration    = data.get("duration")
+        self.answered_by = data.get("answered_by")
+        self.date_created = data.get("date_created")
+
+    def __repr__(self):
+        return f"<Call sid={self.sid!r} status={self.status!r}>"
+
+
+class Client:
+    """Cliente principal para Wirexa API.
+
+    Uso:
+        client = Client(
+            project_id,
+            api_token,
+            signalwire_space_url="your-space.example.com:5000"
+        )
+        call = client.calls.create(to=..., from_=..., url=...)
+    """
+
+    def __init__(
+        self,
+        project_id: str,
+        api_token: str,
+        signalwire_space_url: str = "localhost:5000",
+    ):
+        self.project_id = project_id
+        self.api_token  = api_token
+        self.space_url  = signalwire_space_url
+
+        protocol = "https" if "." in signalwire_space_url and ":" not in signalwire_space_url else "http"
+        self._base_url = (
+            f"{protocol}://{signalwire_space_url}"
+            f"/api/laml/2010-04-01/Accounts/{project_id}"
+        )
+
+        self._auth = (project_id, api_token)
+        self.calls = _CallsResource(self._base_url, self._auth)
+
+    def __repr__(self):
+        return f"<WirexaClient project={self.project_id!r} space={self.space_url!r}>"

wirexaapi-1.0.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: wirexaapi
+Version: 1.0.0
+Summary: Wirexa API SDK - SignalWire/Twilio compatible voice API client
+Author-email: Wirexa Team <dev@wirexa.io>
+License: MIT
+Project-URL: Homepage, https://github.com/wirexa/wirexa-api
+Project-URL: Repository, https://github.com/wirexa/wirexa-api
+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
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# Wirexa API SDK
+
+A production-ready Python SDK for Wirexa API - a self-hosted telephony platform compatible with SignalWire and Twilio REST API.
+
+## Installation
+
+```bash
+pip install wirexaapi
+```
+
+## Quick Start
+
+```python
+from wirexaapi import Client
+
+# Connect to your Wirexa API instance
+client = Client(
+    project_id="your-project-id",
+    api_token="your-api-token", 
+    signalwire_space_url="your-space.example.com:5000"
+)
+
+# Make a call
+call = client.calls.create(
+    to="+573001234567",
+    from_="+18005550100",
+    url="https://your-backend.com/xml",
+    method="POST",
+    timeout=28,
+    record=True,
+    status_callback="https://your-backend.com/status",
+    status_callback_event=["initiated", "ringing", "completed"],
+)
+
+print(f"Call SID: {call.sid}")
+print(f"Call Status: {call.status}")
+```
+
+## Migration from SignalWire
+
+If you're migrating from SignalWire SDK:
+
+```python
+# Before
+from signalwire.rest import Client as SignalWireClient
+
+# After
+from wirexaapi import Client as SignalWireClient
+```
+
+The rest of your code stays the same!
+
+## Features
+
+- Full SignalWire/Twilio API compatibility
+- Call creation, retrieval, and listing
+- Machine Detection (AMD)
+- Recording
+- Status callbacks
+- Async AMD support
+
+## License
+
+MIT

wirexaapi-1.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+wirexaapi/__init__.py,sha256=GGPzaqAvDSp5t3woK9IY-HmxEMHhKVz2CvNVJwnUOZY,6002
+wirexaapi-1.0.0.dist-info/METADATA,sha256=Wo1BpzXryhB8fgg6gAdb3Qgh6yQykbTS3Ou6SqTbsiQ,2132
+wirexaapi-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+wirexaapi-1.0.0.dist-info/top_level.txt,sha256=lWV0OOIgp8Kaq1EdbOFLYcf6JVwfnAaWhE0g3lNg5c0,10
+wirexaapi-1.0.0.dist-info/RECORD,,

wirexaapi-1.0.0.dist-info/WHEEL

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

wirexaapi-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wirexaapi