telnyx 3.8.0__tar.gz → 3.9.0__tar.gz

telnyx-3.9.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "3.9.0"
+}

{telnyx-3.8.0 → telnyx-3.9.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 3.9.0 (2025-10-27)
+
+Full Changelog: [v3.8.0...v3.9.0](https://github.com/team-telnyx/telnyx-python/compare/v3.8.0...v3.9.0)
+
+### Features
+
+* **webhooks:** Implement custom Telnyx webhook verification ([#2](https://github.com/team-telnyx/telnyx-python/issues/2)) ([51e8440](https://github.com/team-telnyx/telnyx-python/commit/51e8440992c3b413d6c91ee5fc33578bc21c27d6))
+
 ## 3.8.0 (2025-10-21)
 
 Full Changelog: [v3.7.0...v3.8.0](https://github.com/team-telnyx/telnyx-python/compare/v3.7.0...v3.8.0)

{telnyx-3.8.0 → telnyx-3.9.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.3
 Name: telnyx
-Version: 3.8.0
-Summary: The official Python library for the telnyx API
+Version: 3.9.0
+Summary: Telnyx API SDK for global Voice, SMS, MMS, WhatsApp, Fax, Wireless IoT, SIP Trunking, and Call Control.
 Project-URL: Homepage, https://github.com/team-telnyx/telnyx-python
 Project-URL: Repository, https://github.com/team-telnyx/telnyx-python
 Author-email: Telnyx <support@telnyx.com>
 License: MIT
+Keywords: api,communications,connectivity,fax,iot,mms,sip,sms,telephony,telnyx,trunking,voice,voip,whatsapp
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS
@@ -32,6 +33,7 @@ Provides-Extra: aiohttp
 Requires-Dist: aiohttp; extra == 'aiohttp'
 Requires-Dist: httpx-aiohttp>=0.1.9; extra == 'aiohttp'
 Provides-Extra: webhooks
+Requires-Dist: pynacl>=1.5.0; extra == 'webhooks'
 Requires-Dist: standardwebhooks; extra == 'webhooks'
 Description-Content-Type: text/markdown
 

{telnyx-3.8.0 → telnyx-3.9.0}/pyproject.toml

@@ -1,12 +1,16 @@
 [project]
 name = "telnyx"
-version = "3.8.0"
-description = "The official Python library for the telnyx API"
+version = "3.9.0"
+description = "Telnyx API SDK for global Voice, SMS, MMS, WhatsApp, Fax, Wireless IoT, SIP Trunking, and Call Control."
 dynamic = ["readme"]
 license = "MIT"
 authors = [
 { name = "Telnyx", email = "support@telnyx.com" },
 ]
+keywords = [
+  "telnyx", "voice", "sms", "mms", "whatsapp", "fax", "iot", "sip", 
+  "trunking", "voip", "telephony", "api", "communications", "connectivity"
+]
 dependencies = [
     "httpx>=0.23.0, <1",
     "pydantic>=1.9.0, <3",
@@ -40,7 +44,7 @@ Repository = "https://github.com/team-telnyx/telnyx-python"
 
 [project.optional-dependencies]
 aiohttp = ["aiohttp", "httpx_aiohttp>=0.1.9"]
-webhooks = ["standardwebhooks"]
+webhooks = ["standardwebhooks", "pynacl>=1.5.0"]
 
 [tool.rye]
 managed = true

{telnyx-3.8.0 → telnyx-3.9.0}/src/telnyx/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "telnyx"
-__version__ = "3.8.0"  # x-release-please-version
+__version__ = "3.9.0"  # x-release-please-version

{telnyx-3.8.0 → telnyx-3.9.0}/src/telnyx/resources/__init__.py

@@ -224,7 +224,7 @@ from .portouts import (
     PortoutsResourceWithStreamingResponse,
     AsyncPortoutsResourceWithStreamingResponse,
 )
-from .webhooks import WebhooksResource, AsyncWebhooksResource
+from .webhooks import TelnyxWebhook, WebhooksResource, AsyncWebhooksResource, TelnyxWebhookVerificationError
 from .wireless import (
     WirelessResource,
     AsyncWirelessResource,
@@ -1237,6 +1237,8 @@ __all__ = [
     "AsyncOAuthGrantsResourceWithStreamingResponse",
     "WebhooksResource",
     "AsyncWebhooksResource",
+    "TelnyxWebhook",
+    "TelnyxWebhookVerificationError",
     "AccessIPAddressResource",
     "AsyncAccessIPAddressResource",
     "AccessIPAddressResourceWithRawResponse",

telnyx-3.9.0/src/telnyx/resources/webhooks.py

@@ -0,0 +1,182 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import json
+from typing import Mapping, cast
+from datetime import datetime, timezone
+
+from .._models import construct_type
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._exceptions import TelnyxError
+from ..types.unwrap_webhook_event import UnwrapWebhookEvent
+from ..types.unsafe_unwrap_webhook_event import UnsafeUnwrapWebhookEvent
+
+__all__ = ["WebhooksResource", "AsyncWebhooksResource", "TelnyxWebhook", "TelnyxWebhookVerificationError"]
+
+
+class TelnyxWebhookVerificationError(TelnyxError):
+    """Raised when webhook verification fails."""
+    pass
+
+
+class TelnyxWebhook:
+    """
+    Telnyx webhook verification following the standardwebhooks pattern.
+    
+    This class provides ED25519 signature verification for Telnyx webhooks
+    using the same interface pattern as the standardwebhooks library.
+    """
+    
+    def __init__(self, key: str | bytes):
+        """
+        Initialize the webhook verifier with a public key.
+        
+        Args:
+            key: The public key for verification (hex string or bytes)
+        """
+        try:
+            from nacl.signing import VerifyKey
+        except ImportError as exc:
+            raise TelnyxError("You need to install `pynacl` to verify Telnyx webhooks") from exc
+        
+        # Convert key to bytes if it's a string
+        if isinstance(key, str):
+            try:
+                key = bytes.fromhex(key)  # Convert from hex string to bytes
+            except ValueError as exc:
+                raise TelnyxWebhookVerificationError(f"Invalid key format: {key!r}") from exc
+        
+        self._verify_key = VerifyKey(key)
+    
+    def verify(self, payload: str, headers: Mapping[str, str]) -> None:
+        """
+        Verify a webhook payload and headers.
+        
+        Args:
+            payload: The webhook payload string
+            headers: The webhook headers
+            
+        Raises:
+            TelnyxWebhookVerificationError: If verification fails
+        """
+        try:
+            from nacl.exceptions import BadSignatureError
+        except ImportError as exc:
+            raise TelnyxError("You need to install `pynacl` to verify Telnyx webhooks") from exc
+        
+        # Extract required headers (case-insensitive lookup)
+        signature_header = headers.get("Telnyx-Signature-Ed25519") or headers.get("telnyx-signature-ed25519")
+        timestamp_header = headers.get("Telnyx-Timestamp") or headers.get("telnyx-timestamp")
+        user_agent = headers.get("User-Agent") or headers.get("user-agent", "")
+
+        # Validate required headers
+        if not signature_header:
+            raise TelnyxWebhookVerificationError("Missing required header: Telnyx-Signature-Ed25519")
+        
+        if not timestamp_header:
+            raise TelnyxWebhookVerificationError("Missing required header: Telnyx-Timestamp")
+
+        # Verify User-Agent if present (optional security check)
+        if user_agent and "telnyx-webhooks" not in user_agent.lower():
+            raise TelnyxWebhookVerificationError(f"Unexpected User-Agent: {user_agent}")
+
+        # Validate timestamp format and prevent replay attacks
+        try:
+            webhook_time = int(timestamp_header)
+            current_time = int(datetime.now(timezone.utc).timestamp())
+            
+            # Allow 5 minutes tolerance
+            if abs(current_time - webhook_time) > 300:
+                raise TelnyxWebhookVerificationError(
+                    f"Webhook timestamp too old or too new: {timestamp_header}"
+                )
+        except ValueError as exc:
+            raise TelnyxWebhookVerificationError(
+                f"Invalid timestamp format: {timestamp_header}"
+            ) from exc
+
+        # Decode the signature from hex
+        try:
+            signature = bytes.fromhex(signature_header)
+        except ValueError as exc:
+            raise TelnyxWebhookVerificationError(
+                f"Invalid signature format: {signature_header}"
+            ) from exc
+
+        # Create the signed payload: timestamp + payload
+        signed_payload = timestamp_header.encode('utf-8') + payload.encode('utf-8')
+
+        # Verify the signature
+        try:
+            self._verify_key.verify(signed_payload, signature)
+        except BadSignatureError as exc:
+            raise TelnyxWebhookVerificationError("Invalid webhook signature") from exc
+
+
+class WebhooksResource(SyncAPIResource):
+    def unsafe_unwrap(self, payload: str) -> UnsafeUnwrapWebhookEvent:
+        return cast(
+            UnsafeUnwrapWebhookEvent,
+            construct_type(
+                type_=UnsafeUnwrapWebhookEvent,
+                value=json.loads(payload),
+            ),
+        )
+
+    def unwrap(self, payload: str, *, headers: Mapping[str, str], key: str | bytes | None = None) -> UnwrapWebhookEvent:
+        if key is None:
+            key = self._client.public_key
+            if key is None:
+                raise ValueError(
+                    "Cannot verify a webhook without a key on either the client's public_key or passed in as an argument"
+                )
+
+        if not isinstance(headers, dict):
+            headers = dict(headers)
+
+        # Use Telnyx-specific webhook verification following standardwebhooks pattern
+        webhook = TelnyxWebhook(key)
+        webhook.verify(payload, headers)
+
+        return cast(
+            UnwrapWebhookEvent,
+            construct_type(
+                type_=UnwrapWebhookEvent,
+                value=json.loads(payload),
+            ),
+        )
+
+
+class AsyncWebhooksResource(AsyncAPIResource):
+    def unsafe_unwrap(self, payload: str) -> UnsafeUnwrapWebhookEvent:
+        return cast(
+            UnsafeUnwrapWebhookEvent,
+            construct_type(
+                type_=UnsafeUnwrapWebhookEvent,
+                value=json.loads(payload),
+            ),
+        )
+
+    def unwrap(self, payload: str, *, headers: Mapping[str, str], key: str | bytes | None = None) -> UnwrapWebhookEvent:
+        if key is None:
+            key = self._client.public_key
+            if key is None:
+                raise ValueError(
+                    "Cannot verify a webhook without a key on either the client's public_key or passed in as an argument"
+                )
+
+        if not isinstance(headers, dict):
+            headers = dict(headers)
+
+        # Use Telnyx-specific webhook verification following standardwebhooks pattern
+        webhook = TelnyxWebhook(key)
+        webhook.verify(payload, headers)
+
+        return cast(
+            UnwrapWebhookEvent,
+            construct_type(
+                type_=UnwrapWebhookEvent,
+                value=json.loads(payload),
+            ),
+        )

telnyx-3.9.0/tests/api_resources/test_webhooks.py

@@ -0,0 +1,194 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+import time
+
+import pytest
+
+try:
+    from nacl.signing import SigningKey
+    from nacl.encoding import HexEncoder
+except ImportError:
+    pytest.skip("pynacl is required for webhook tests", allow_module_level=True)
+
+from telnyx import Telnyx
+from telnyx.resources.webhooks import TelnyxWebhook, TelnyxWebhookVerificationError
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestWebhooks:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    def test_method_unwrap(self, client: Telnyx) -> None:
+        # Generate a test key pair for Telnyx ED25519 verification
+        signing_key = SigningKey.generate()
+        verify_key_hex = signing_key.verify_key.encode(encoder=HexEncoder).decode('utf-8')
+
+        data = """{"data":{"id":"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0","event_type":"call.ai_gather.ended","occurred_at":"2018-02-02T22:25:27.521992Z","payload":{"call_control_id":"v2:T02llQxIyaRkhfRKxgAP8nY511EhFLizdvdUKJiSw8d6A9BborherQ","call_leg_id":"428c31b6-7af4-4bcb-b7f5-5013ef9657c1","call_session_id":"428c31b6-7af4-4bcb-b7f5-5013ef9657c1","client_state":"aGF2ZSBhIG5pY2UgZGF5ID1d","connection_id":"7267xxxxxxxxxxxxxx","from":"+35319605860","message_history":[{"content":"Hello, can you tell me your age and where you live?","role":"assistant"},{"content":"Hello, I'm 29 and I live in Paris?","role":"user"}],"result":{"age":29,"city":"Paris"},"status":"valid","to":"+35319605860"},"record_type":"event"}}"""
+        
+        # Create timestamp and Telnyx-style signature
+        timestamp = str(int(time.time()))
+        signed_payload = timestamp.encode('utf-8') + data.encode('utf-8')
+        signature = signing_key.sign(signed_payload, encoder=HexEncoder).signature.decode('utf-8')
+        
+        headers = {
+            "Telnyx-Signature-Ed25519": signature,
+            "Telnyx-Timestamp": timestamp,
+            "User-Agent": "telnyx-webhooks"
+        }
+
+        try:
+            result = client.webhooks.unwrap(data, headers=headers, key=verify_key_hex)
+            # Verify the result is properly parsed
+            assert result.data.event_type == "call.ai_gather.ended"  # type: ignore[reportUnknownMemberType]
+            assert result.data.payload.call_control_id == "v2:T02llQxIyaRkhfRKxgAP8nY511EhFLizdvdUKJiSw8d6A9BborherQ"  # type: ignore[reportUnknownMemberType]
+        except TelnyxWebhookVerificationError as e:
+            raise AssertionError("Failed to unwrap valid webhook") from e
+
+        # Test invalid signature
+        bad_headers = [
+            {**headers, "Telnyx-Signature-Ed25519": "invalid_signature"},
+            {**headers, "Telnyx-Timestamp": "0"},
+            {**headers, "User-Agent": "malicious-bot"},
+        ]
+        for bad_header in bad_headers:
+            with pytest.raises(TelnyxWebhookVerificationError):
+                _ = client.webhooks.unwrap(data, headers=bad_header, key=verify_key_hex)
+
+        # Test missing headers
+        incomplete_headers = {
+            "Telnyx-Timestamp": timestamp,
+            "User-Agent": "telnyx-webhooks"
+        }
+        with pytest.raises(TelnyxWebhookVerificationError):
+            _ = client.webhooks.unwrap(data, headers=incomplete_headers, key=verify_key_hex)
+
+        # Test case-insensitive headers
+        lowercase_headers = {
+            "telnyx-signature-ed25519": signature,
+            "telnyx-timestamp": timestamp,
+            "user-agent": "telnyx-webhooks"
+        }
+        try:
+            result = client.webhooks.unwrap(data, headers=lowercase_headers, key=verify_key_hex)
+            assert result.data.event_type == "call.ai_gather.ended"  # type: ignore[reportUnknownMemberType]
+        except TelnyxWebhookVerificationError as e:
+            raise AssertionError("Failed to unwrap webhook with lowercase headers") from e
+
+
+class TestAsyncWebhooks:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    def test_method_unwrap(self, client: Telnyx) -> None:
+        # Generate a test key pair for Telnyx ED25519 verification
+        signing_key = SigningKey.generate()
+        verify_key_hex = signing_key.verify_key.encode(encoder=HexEncoder).decode('utf-8')
+
+        data = """{"data":{"id":"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0","event_type":"call.ai_gather.ended","occurred_at":"2018-02-02T22:25:27.521992Z","payload":{"call_control_id":"v2:T02llQxIyaRkhfRKxgAP8nY511EhFLizdvdUKJiSw8d6A9BborherQ","call_leg_id":"428c31b6-7af4-4bcb-b7f5-5013ef9657c1","call_session_id":"428c31b6-7af4-4bcb-b7f5-5013ef9657c1","client_state":"aGF2ZSBhIG5pY2UgZGF5ID1d","connection_id":"7267xxxxxxxxxxxxxx","from":"+35319605860","message_history":[{"content":"Hello, can you tell me your age and where you live?","role":"assistant"},{"content":"Hello, I'm 29 and I live in Paris?","role":"user"}],"result":{"age":29,"city":"Paris"},"status":"valid","to":"+35319605860"},"record_type":"event"}}"""
+        
+        # Create timestamp and Telnyx-style signature
+        timestamp = str(int(time.time()))
+        signed_payload = timestamp.encode('utf-8') + data.encode('utf-8')
+        signature = signing_key.sign(signed_payload, encoder=HexEncoder).signature.decode('utf-8')
+        
+        headers = {
+            "Telnyx-Signature-Ed25519": signature,
+            "Telnyx-Timestamp": timestamp,
+            "User-Agent": "telnyx-webhooks"
+        }
+
+        try:
+            result = client.webhooks.unwrap(data, headers=headers, key=verify_key_hex)
+            # Verify the result is properly parsed
+            assert result.data.event_type == "call.ai_gather.ended"  # type: ignore[reportUnknownMemberType]
+            assert result.data.payload.call_control_id == "v2:T02llQxIyaRkhfRKxgAP8nY511EhFLizdvdUKJiSw8d6A9BborherQ"  # type: ignore[reportUnknownMemberType]
+        except TelnyxWebhookVerificationError as e:
+            raise AssertionError("Failed to unwrap valid webhook") from e
+
+        # Test invalid signature
+        bad_headers = [
+            {**headers, "Telnyx-Signature-Ed25519": "invalid_signature"},
+            {**headers, "Telnyx-Timestamp": "0"},
+            {**headers, "User-Agent": "malicious-bot"},
+        ]
+        for bad_header in bad_headers:
+            with pytest.raises(TelnyxWebhookVerificationError):
+                _ = client.webhooks.unwrap(data, headers=bad_header, key=verify_key_hex)
+
+        # Test missing headers
+        incomplete_headers = {
+            "Telnyx-Timestamp": timestamp,
+            "User-Agent": "telnyx-webhooks"
+        }
+        with pytest.raises(TelnyxWebhookVerificationError):
+            _ = client.webhooks.unwrap(data, headers=incomplete_headers, key=verify_key_hex)
+class TestTelnyxWebhook:
+    """Test the TelnyxWebhook class directly to ensure it follows standardwebhooks pattern."""
+
+    def test_webhook_initialization(self) -> None:
+        """Test that TelnyxWebhook can be initialized like standardwebhooks.Webhook."""
+        signing_key = SigningKey.generate()
+        verify_key_hex = signing_key.verify_key.encode(encoder=HexEncoder).decode('utf-8')
+        
+        # Should initialize like standardwebhooks.Webhook
+        webhook = TelnyxWebhook(verify_key_hex)
+        assert webhook is not None
+        assert hasattr(webhook, 'verify')
+
+    def test_webhook_verification_pattern(self) -> None:
+        """Test that TelnyxWebhook.verify follows the same pattern as standardwebhooks.Webhook.verify."""
+        signing_key = SigningKey.generate()
+        verify_key_hex = signing_key.verify_key.encode(encoder=HexEncoder).decode('utf-8')
+        
+        data = """{"test": "payload"}"""
+        timestamp = str(int(time.time()))
+        signed_payload = timestamp.encode('utf-8') + data.encode('utf-8')
+        signature = signing_key.sign(signed_payload, encoder=HexEncoder).signature.decode('utf-8')
+        
+        headers = {
+            "Telnyx-Signature-Ed25519": signature,
+            "Telnyx-Timestamp": timestamp,
+            "User-Agent": "telnyx-webhooks"
+        }
+        
+        # Should verify like standardwebhooks.Webhook.verify
+        webhook = TelnyxWebhook(verify_key_hex)
+        
+        # Valid webhook should not raise exception
+        webhook.verify(data, headers)
+        
+        # Invalid webhook should raise TelnyxWebhookVerificationError
+        with pytest.raises(TelnyxWebhookVerificationError):
+            webhook.verify(data, {**headers, "Telnyx-Signature-Ed25519": "invalid"})
+
+    def test_exception_hierarchy(self) -> None:
+        """Test that TelnyxWebhookVerificationError follows the right pattern."""
+        # Should be importable like standardwebhooks.WebhookVerificationError
+        assert TelnyxWebhookVerificationError is not None
+        
+        # Should be able to raise and catch it
+        with pytest.raises(TelnyxWebhookVerificationError):
+            raise TelnyxWebhookVerificationError("Test error")
+
+    def test_key_format_handling(self) -> None:
+        """Test that TelnyxWebhook handles different key formats like standardwebhooks."""
+        signing_key = SigningKey.generate()
+        verify_key_hex = signing_key.verify_key.encode(encoder=HexEncoder).decode('utf-8')
+        verify_key_bytes = signing_key.verify_key.encode()
+        
+        # Should accept hex string (Telnyx format)
+        webhook1 = TelnyxWebhook(verify_key_hex)
+        assert webhook1 is not None
+        
+        # Should accept bytes (standardwebhooks format)
+        webhook2 = TelnyxWebhook(verify_key_bytes)
+        assert webhook2 is not None
+        
+        # Should reject invalid key format
+        with pytest.raises(TelnyxWebhookVerificationError):
+            TelnyxWebhook("invalid_key_format")

telnyx-3.8.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "3.8.0"
-}

telnyx-3.8.0/src/telnyx/resources/webhooks.py

@@ -1,88 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import json
-from typing import Mapping, cast
-
-from .._models import construct_type
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._exceptions import TelnyxError
-from ..types.unwrap_webhook_event import UnwrapWebhookEvent
-from ..types.unsafe_unwrap_webhook_event import UnsafeUnwrapWebhookEvent
-
-__all__ = ["WebhooksResource", "AsyncWebhooksResource"]
-
-
-class WebhooksResource(SyncAPIResource):
-    def unsafe_unwrap(self, payload: str) -> UnsafeUnwrapWebhookEvent:
-        return cast(
-            UnsafeUnwrapWebhookEvent,
-            construct_type(
-                type_=UnsafeUnwrapWebhookEvent,
-                value=json.loads(payload),
-            ),
-        )
-
-    def unwrap(self, payload: str, *, headers: Mapping[str, str], key: str | bytes | None = None) -> UnwrapWebhookEvent:
-        try:
-            from standardwebhooks import Webhook
-        except ImportError as exc:
-            raise TelnyxError("You need to install `telnyx[webhooks]` to use this method") from exc
-
-        if key is None:
-            key = self._client.public_key
-            if key is None:
-                raise ValueError(
-                    "Cannot verify a webhook without a key on either the client's public_key or passed in as an argument"
-                )
-
-        if not isinstance(headers, dict):
-            headers = dict(headers)
-
-        Webhook(key).verify(payload, headers)
-
-        return cast(
-            UnwrapWebhookEvent,
-            construct_type(
-                type_=UnwrapWebhookEvent,
-                value=json.loads(payload),
-            ),
-        )
-
-
-class AsyncWebhooksResource(AsyncAPIResource):
-    def unsafe_unwrap(self, payload: str) -> UnsafeUnwrapWebhookEvent:
-        return cast(
-            UnsafeUnwrapWebhookEvent,
-            construct_type(
-                type_=UnsafeUnwrapWebhookEvent,
-                value=json.loads(payload),
-            ),
-        )
-
-    def unwrap(self, payload: str, *, headers: Mapping[str, str], key: str | bytes | None = None) -> UnwrapWebhookEvent:
-        try:
-            from standardwebhooks import Webhook
-        except ImportError as exc:
-            raise TelnyxError("You need to install `telnyx[webhooks]` to use this method") from exc
-
-        if key is None:
-            key = self._client.public_key
-            if key is None:
-                raise ValueError(
-                    "Cannot verify a webhook without a key on either the client's public_key or passed in as an argument"
-                )
-
-        if not isinstance(headers, dict):
-            headers = dict(headers)
-
-        Webhook(key).verify(payload, headers)
-
-        return cast(
-            UnwrapWebhookEvent,
-            construct_type(
-                type_=UnwrapWebhookEvent,
-                value=json.loads(payload),
-            ),
-        )

telnyx-3.8.0/tests/api_resources/test_webhooks.py

@@ -1,79 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import os
-from datetime import datetime, timezone
-
-import pytest
-import standardwebhooks
-
-from telnyx import Telnyx
-
-base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
-
-
-class TestWebhooks:
-    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
-
-    def test_method_unwrap(self, client: Telnyx) -> None:
-        key = b"secret"
-        hook = standardwebhooks.Webhook(key)
-
-        data = """{"data":{"id":"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0","event_type":"call.ai_gather.ended","occurred_at":"2018-02-02T22:25:27.521992Z","payload":{"call_control_id":"v2:T02llQxIyaRkhfRKxgAP8nY511EhFLizdvdUKJiSw8d6A9BborherQ","call_leg_id":"428c31b6-7af4-4bcb-b7f5-5013ef9657c1","call_session_id":"428c31b6-7af4-4bcb-b7f5-5013ef9657c1","client_state":"aGF2ZSBhIG5pY2UgZGF5ID1d","connection_id":"7267xxxxxxxxxxxxxx","from":"+35319605860","message_history":[{"content":"Hello, can you tell me your age and where you live?","role":"assistant"},{"content":"Hello, I'm 29 and I live in Paris?","role":"user"}],"result":{"age":29,"city":"Paris"},"status":"valid","to":"+35319605860"},"record_type":"event"}}"""
-        msg_id = "1"
-        timestamp = datetime.now(tz=timezone.utc)
-        sig = hook.sign(msg_id=msg_id, timestamp=timestamp, data=data)
-        headers = {
-            "webhook-id": msg_id,
-            "webhook-timestamp": str(int(timestamp.timestamp())),
-            "webhook-signature": sig,
-        }
-
-        try:
-            _ = client.webhooks.unwrap(data, headers=headers, key=key)
-        except standardwebhooks.WebhookVerificationError as e:
-            raise AssertionError("Failed to unwrap valid webhook") from e
-
-        bad_headers = [
-            {**headers, "webhook-signature": hook.sign(msg_id=msg_id, timestamp=timestamp, data="xxx")},
-            {**headers, "webhook-id": "bad"},
-            {**headers, "webhook-timestamp": "0"},
-        ]
-        for bad_header in bad_headers:
-            with pytest.raises(standardwebhooks.WebhookVerificationError):
-                _ = client.webhooks.unwrap(data, headers=bad_header, key=key)
-
-
-class TestAsyncWebhooks:
-    parametrize = pytest.mark.parametrize(
-        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
-    )
-
-    def test_method_unwrap(self, client: Telnyx) -> None:
-        key = b"secret"
-        hook = standardwebhooks.Webhook(key)
-
-        data = """{"data":{"id":"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0","event_type":"call.ai_gather.ended","occurred_at":"2018-02-02T22:25:27.521992Z","payload":{"call_control_id":"v2:T02llQxIyaRkhfRKxgAP8nY511EhFLizdvdUKJiSw8d6A9BborherQ","call_leg_id":"428c31b6-7af4-4bcb-b7f5-5013ef9657c1","call_session_id":"428c31b6-7af4-4bcb-b7f5-5013ef9657c1","client_state":"aGF2ZSBhIG5pY2UgZGF5ID1d","connection_id":"7267xxxxxxxxxxxxxx","from":"+35319605860","message_history":[{"content":"Hello, can you tell me your age and where you live?","role":"assistant"},{"content":"Hello, I'm 29 and I live in Paris?","role":"user"}],"result":{"age":29,"city":"Paris"},"status":"valid","to":"+35319605860"},"record_type":"event"}}"""
-        msg_id = "1"
-        timestamp = datetime.now(tz=timezone.utc)
-        sig = hook.sign(msg_id=msg_id, timestamp=timestamp, data=data)
-        headers = {
-            "webhook-id": msg_id,
-            "webhook-timestamp": str(int(timestamp.timestamp())),
-            "webhook-signature": sig,
-        }
-
-        try:
-            _ = client.webhooks.unwrap(data, headers=headers, key=key)
-        except standardwebhooks.WebhookVerificationError as e:
-            raise AssertionError("Failed to unwrap valid webhook") from e
-
-        bad_headers = [
-            {**headers, "webhook-signature": hook.sign(msg_id=msg_id, timestamp=timestamp, data="xxx")},
-            {**headers, "webhook-id": "bad"},
-            {**headers, "webhook-timestamp": "0"},
-        ]
-        for bad_header in bad_headers:
-            with pytest.raises(standardwebhooks.WebhookVerificationError):
-                _ = client.webhooks.unwrap(data, headers=bad_header, key=key)