posthook-python 1.0.0__tar.gz → 1.1.0__tar.gz

{posthook_python-1.0.0 → posthook_python-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: posthook-python
-Version: 1.0.0
+Version: 1.1.0
 Summary: The official Python client library for the Posthook API
 Project-URL: Homepage, https://posthook.io
 Project-URL: Documentation, https://posthook.io/docs
@@ -354,6 +354,74 @@ delivery = client.signatures.parse_delivery(
 )
 ```
 
+## Async Hooks
+
+When [async hooks](https://posthook.io/docs/essentials/async-hooks) are enabled, `parse_delivery()` populates `ack_url` and `nack_url` on the delivery object. Return 202 from your handler and call back when processing completes.
+
+### FastAPI
+
+```python
+from fastapi import FastAPI, Request, BackgroundTasks, HTTPException
+from fastapi.responses import Response
+import posthook
+
+app = FastAPI()
+client = posthook.Posthook("pk_...", signing_key="ph_sk_...")
+
+async def process_and_ack(delivery):
+    try:
+        await process_video(delivery.data["video_id"])
+        result = await posthook.async_ack(delivery.ack_url)
+        print(f"Applied: {result.applied}")
+    except Exception as e:
+        await posthook.async_nack(delivery.nack_url, {"error": str(e)})
+
+@app.post("/webhooks/process-video")
+async def handle_webhook(request: Request, background_tasks: BackgroundTasks):
+    body = await request.body()
+    try:
+        delivery = client.signatures.parse_delivery(body=body, headers=dict(request.headers))
+    except posthook.SignatureVerificationError:
+        raise HTTPException(status_code=401)
+
+    background_tasks.add_task(process_and_ack, delivery)
+    return Response(status_code=202)
+```
+
+### Callback functions
+
+The SDK provides standalone callback functions -- pass the URL from the delivery object:
+
+```python
+# Sync (Flask, Django, background workers)
+result = posthook.ack(delivery.ack_url)
+result = posthook.nack(delivery.nack_url, {"error": "processing failed"})
+
+# Async (FastAPI, etc.)
+result = await posthook.async_ack(delivery.ack_url)
+result = await posthook.async_nack(delivery.nack_url, {"error": "processing failed"})
+```
+
+Both return a `CallbackResult`:
+
+```python
+result = posthook.ack(delivery.ack_url)
+print(result.applied)  # True if state changed, False if already resolved
+print(result.status)   # "completed", "not_found", "conflict", etc.
+```
+
+`ack()` and `nack()` return normally for `200`, `404`, and `409` responses. They raise `CallbackError` for `401` (invalid token) and `410` (expired).
+
+If processing happens in a separate worker, use the raw callback URLs instead:
+
+```python
+queue.enqueue("transcode", {
+    "video_id": delivery.data["video_id"],
+    "ack_url": delivery.ack_url,
+    "nack_url": delivery.nack_url,
+})
+```
+
 ## Error Handling
 
 All API errors extend `PosthookError` and can be caught with `isinstance` or `except`:

{posthook_python-1.0.0 → posthook_python-1.1.0}/README.md

@@ -330,6 +330,74 @@ delivery = client.signatures.parse_delivery(
 )
 ```
 
+## Async Hooks
+
+When [async hooks](https://posthook.io/docs/essentials/async-hooks) are enabled, `parse_delivery()` populates `ack_url` and `nack_url` on the delivery object. Return 202 from your handler and call back when processing completes.
+
+### FastAPI
+
+```python
+from fastapi import FastAPI, Request, BackgroundTasks, HTTPException
+from fastapi.responses import Response
+import posthook
+
+app = FastAPI()
+client = posthook.Posthook("pk_...", signing_key="ph_sk_...")
+
+async def process_and_ack(delivery):
+    try:
+        await process_video(delivery.data["video_id"])
+        result = await posthook.async_ack(delivery.ack_url)
+        print(f"Applied: {result.applied}")
+    except Exception as e:
+        await posthook.async_nack(delivery.nack_url, {"error": str(e)})
+
+@app.post("/webhooks/process-video")
+async def handle_webhook(request: Request, background_tasks: BackgroundTasks):
+    body = await request.body()
+    try:
+        delivery = client.signatures.parse_delivery(body=body, headers=dict(request.headers))
+    except posthook.SignatureVerificationError:
+        raise HTTPException(status_code=401)
+
+    background_tasks.add_task(process_and_ack, delivery)
+    return Response(status_code=202)
+```
+
+### Callback functions
+
+The SDK provides standalone callback functions -- pass the URL from the delivery object:
+
+```python
+# Sync (Flask, Django, background workers)
+result = posthook.ack(delivery.ack_url)
+result = posthook.nack(delivery.nack_url, {"error": "processing failed"})
+
+# Async (FastAPI, etc.)
+result = await posthook.async_ack(delivery.ack_url)
+result = await posthook.async_nack(delivery.nack_url, {"error": "processing failed"})
+```
+
+Both return a `CallbackResult`:
+
+```python
+result = posthook.ack(delivery.ack_url)
+print(result.applied)  # True if state changed, False if already resolved
+print(result.status)   # "completed", "not_found", "conflict", etc.
+```
+
+`ack()` and `nack()` return normally for `200`, `404`, and `409` responses. They raise `CallbackError` for `401` (invalid token) and `410` (expired).
+
+If processing happens in a separate worker, use the raw callback URLs instead:
+
+```python
+queue.enqueue("transcode", {
+    "video_id": delivery.data["video_id"],
+    "ack_url": delivery.ack_url,
+    "nack_url": delivery.nack_url,
+})
+```
+
 ## Error Handling
 
 All API errors extend `PosthookError` and can be caught with `isinstance` or `except`:

{posthook_python-1.0.0 → posthook_python-1.1.0}/src/posthook/__init__.py

@@ -1,9 +1,11 @@
 """Posthook Python SDK — schedule, manage, and verify webhooks."""
 
+from ._callbacks import ack, async_ack, async_nack, nack
 from ._client import AsyncPosthook, Posthook
 from ._errors import (
     AuthenticationError,
     BadRequestError,
+    CallbackError,
     ForbiddenError,
     InternalServerError,
     NotFoundError,
@@ -25,6 +27,7 @@ from ._models import (
     STRATEGY_EXPONENTIAL,
     STRATEGY_FIXED,
     BulkActionResult,
+    CallbackResult,
     Delivery,
     Hook,
     HookRetryOverride,
@@ -42,7 +45,13 @@ __all__ = [
     "HookRetryOverride",
     "QuotaInfo",
     "BulkActionResult",
+    "CallbackResult",
     "Delivery",
+    # Callbacks
+    "ack",
+    "nack",
+    "async_ack",
+    "async_nack",
     # Resources
     "SignaturesService",
     "create_signatures",
@@ -61,6 +70,7 @@ __all__ = [
     "PosthookError",
     "BadRequestError",
     "AuthenticationError",
+    "CallbackError",
     "ForbiddenError",
     "NotFoundError",
     "PayloadTooLargeError",

posthook_python-1.1.0/src/posthook/_callbacks.py

@@ -0,0 +1,127 @@
+"""Sync and async helpers for ack/nack callbacks on async hook deliveries."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+from ._errors import CallbackError
+from ._models import CallbackResult
+
+
+def _parse_callback_response(
+    response: httpx.Response,
+    action: str,
+    expected_status: str,
+) -> CallbackResult:
+    """Parse an ack/nack HTTP response into a CallbackResult.
+
+    2xx → parse ``{data: {status}}`` from JSON, ``applied = (status == expected)``.
+    404 → ``CallbackResult(applied=False, status="not_found")``.
+    409 → ``CallbackResult(applied=False, status="conflict")``.
+    Other → raise ``CallbackError``.
+    """
+    if response.is_success:
+        try:
+            data = response.json()
+            status = data.get("data", {}).get("status", "unknown")
+        except Exception:
+            status = "unknown"
+        return CallbackResult(applied=(status == expected_status), status=status)
+
+    if response.status_code == 404:
+        return CallbackResult(applied=False, status="not_found")
+    if response.status_code == 409:
+        return CallbackResult(applied=False, status="conflict")
+
+    text = response.text
+    suffix = f": {text}" if text else ""
+    raise CallbackError(
+        f"{action} failed: {response.status_code}{suffix}",
+        status_code=response.status_code,
+    )
+
+
+def _prepare_request(body: Any) -> tuple[bytes | None, dict[str, str]]:
+    """Prepare content and headers for a callback request."""
+    if body is not None:
+        return json.dumps(body).encode(), {"Content-Type": "application/json"}
+    return None, {}
+
+
+def ack(url: str, body: Any = None) -> CallbackResult:
+    """Acknowledge async processing completion (synchronous).
+
+    Args:
+        url: The ack callback URL from ``delivery.ack_url``.
+        body: Optional JSON-serializable body to send with the callback.
+            Posthook currently ignores ack bodies.
+
+    Returns:
+        A ``CallbackResult`` indicating whether the ack was applied.
+
+    Raises:
+        CallbackError: For unexpected failures (401, 410, 5xx).
+    """
+    content, headers = _prepare_request(body)
+    response = httpx.post(url, content=content, headers=headers)
+    return _parse_callback_response(response, "ack", "completed")
+
+
+def nack(url: str, body: Any = None) -> CallbackResult:
+    """Reject async processing — triggers retry or failure (synchronous).
+
+    Args:
+        url: The nack callback URL from ``delivery.nack_url``.
+        body: Optional JSON-serializable body explaining the failure.
+
+    Returns:
+        A ``CallbackResult`` indicating whether the nack was applied.
+
+    Raises:
+        CallbackError: For unexpected failures (401, 410, 5xx).
+    """
+    content, headers = _prepare_request(body)
+    response = httpx.post(url, content=content, headers=headers)
+    return _parse_callback_response(response, "nack", "nacked")
+
+
+async def async_ack(url: str, body: Any = None) -> CallbackResult:
+    """Acknowledge async processing completion (asynchronous).
+
+    Args:
+        url: The ack callback URL from ``delivery.ack_url``.
+        body: Optional JSON-serializable body to send with the callback.
+            Posthook currently ignores ack bodies.
+
+    Returns:
+        A ``CallbackResult`` indicating whether the ack was applied.
+
+    Raises:
+        CallbackError: For unexpected failures (401, 410, 5xx).
+    """
+    content, headers = _prepare_request(body)
+    async with httpx.AsyncClient() as client:
+        response = await client.post(url, content=content, headers=headers)
+    return _parse_callback_response(response, "ack", "completed")
+
+
+async def async_nack(url: str, body: Any = None) -> CallbackResult:
+    """Reject async processing — triggers retry or failure (asynchronous).
+
+    Args:
+        url: The nack callback URL from ``delivery.nack_url``.
+        body: Optional JSON-serializable body explaining the failure.
+
+    Returns:
+        A ``CallbackResult`` indicating whether the nack was applied.
+
+    Raises:
+        CallbackError: For unexpected failures (401, 410, 5xx).
+    """
+    content, headers = _prepare_request(body)
+    async with httpx.AsyncClient() as client:
+        response = await client.post(url, content=content, headers=headers)
+    return _parse_callback_response(response, "nack", "nacked")

{posthook_python-1.0.0 → posthook_python-1.1.0}/src/posthook/_errors.py

@@ -97,6 +97,19 @@ class SignatureVerificationError(PosthookError):
         super().__init__(message, code="signature_verification_error")
 
 
+class CallbackError(PosthookError):
+    """Raised when an ack/nack callback fails unexpectedly.
+
+    This is thrown for non-recoverable failures such as invalid tokens (401),
+    expired tokens (410), or server errors (5xx). Expected no-ops like 404
+    (hook deleted) and 409 (stale token) are returned as ``CallbackResult``
+    with ``applied=False`` instead.
+    """
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message, status_code=status_code, code="callback_error")
+
+
 def _create_error(
     status_code: int,
     message: str,

{posthook_python-1.0.0 → posthook_python-1.1.0}/src/posthook/_models.py

@@ -148,6 +148,21 @@ class BulkActionResult:
 
 
 @dataclass(frozen=True)
+class CallbackResult:
+    """Result of an ack or nack callback.
+
+    Both ``ack()`` and ``nack()`` return this for all expected outcomes,
+    including race conditions where the hook already resolved. Check
+    ``applied`` to see if your callback changed the hook's state.
+    """
+
+    applied: bool
+    """Whether the callback changed the hook's state."""
+    status: str
+    """The hook's current status (e.g. ``"completed"``, ``"nacked"``, ``"not_found"``)."""
+
+
+@dataclass
 class Delivery:
     """A parsed and verified webhook delivery."""
 
@@ -160,3 +175,7 @@ class Delivery:
     posted_at: datetime
     created_at: datetime
     updated_at: datetime
+    ack_url: str | None = None
+    """Callback URL for acknowledging async processing. Present when both ack and nack headers exist."""
+    nack_url: str | None = None
+    """Callback URL for negative acknowledgement. Present when both ack and nack headers exist."""

{posthook_python-1.0.0 → posthook_python-1.1.0}/src/posthook/_resources/_signatures.py

@@ -128,6 +128,11 @@ class SignaturesService:
                 f"Failed to parse delivery payload: {exc}"
             )
 
+        # Extract async callback URLs (set both or neither).
+        ack_url = _get_header(headers, "Posthook-Ack-URL")
+        nack_url = _get_header(headers, "Posthook-Nack-URL")
+        has_callbacks = bool(ack_url and nack_url)
+
         return Delivery(
             hook_id=hook_id,
             timestamp=timestamp,
@@ -138,6 +143,8 @@ class SignaturesService:
             posted_at=_parse_dt(payload.get("postedAt", "")),
             created_at=_parse_dt(payload.get("createdAt", "")),
             updated_at=_parse_dt(payload.get("updatedAt", "")),
+            ack_url=ack_url if has_callbacks else None,
+            nack_url=nack_url if has_callbacks else None,
         )
 
 

posthook_python-1.1.0/src/posthook/_version.py

@@ -0,0 +1 @@
+VERSION = "1.1.0"

posthook_python-1.1.0/tests/test_callbacks.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+
+import posthook
+from posthook import CallbackError, CallbackResult
+from posthook._callbacks import ack, async_ack, async_nack, nack
+
+
+# ─── Helpers ────────────────────────────────────────────────────────
+
+
+def _mock_response(
+    status_code: int,
+    body: dict | None = None,
+    text: str = "",
+) -> httpx.Response:
+    if body is not None:
+        return httpx.Response(status_code, json=body)
+    return httpx.Response(status_code, text=text)
+
+
+# ─── Sync ack() ─────────────────────────────────────────────────────
+
+
+class TestAckSync:
+    def test_success_applied(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(200, {"data": {"status": "completed"}}),
+        )
+        result = ack("https://api.posthook.io/ack/token123")
+        assert result == CallbackResult(applied=True, status="completed")
+
+    def test_success_not_applied(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Server returns 200 but status is not 'completed' (idempotent no-op)."""
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(200, {"data": {"status": "nacked"}}),
+        )
+        result = ack("https://api.posthook.io/ack/token123")
+        assert result == CallbackResult(applied=False, status="nacked")
+
+    def test_404_not_found(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(404),
+        )
+        result = ack("https://api.posthook.io/ack/token123")
+        assert result == CallbackResult(applied=False, status="not_found")
+
+    def test_409_conflict(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(409),
+        )
+        result = ack("https://api.posthook.io/ack/token123")
+        assert result == CallbackResult(applied=False, status="conflict")
+
+    def test_401_raises_callback_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(401, text="unauthorized"),
+        )
+        with pytest.raises(CallbackError, match="ack failed: 401"):
+            ack("https://api.posthook.io/ack/token123")
+
+    def test_410_raises_callback_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(410, text="gone"),
+        )
+        with pytest.raises(CallbackError, match="ack failed: 410"):
+            ack("https://api.posthook.io/ack/token123")
+
+    def test_500_raises_callback_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(500, text="internal error"),
+        )
+        with pytest.raises(CallbackError, match="ack failed: 500"):
+            ack("https://api.posthook.io/ack/token123")
+
+    def test_json_body_sent(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Verify that a JSON body is serialized and Content-Type is set."""
+        captured: dict = {}
+
+        def mock_post(url: str, **kwargs) -> httpx.Response:
+            captured["content"] = kwargs.get("content")
+            captured["headers"] = kwargs.get("headers")
+            return _mock_response(200, {"data": {"status": "completed"}})
+
+        monkeypatch.setattr(httpx, "post", mock_post)
+        ack("https://api.posthook.io/ack/token123", body={"done": True})
+
+        assert json.loads(captured["content"]) == {"done": True}
+        assert captured["headers"]["Content-Type"] == "application/json"
+
+    def test_no_body_no_content_type(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Without a body, no Content-Type header should be sent."""
+        captured: dict = {}
+
+        def mock_post(url: str, **kwargs) -> httpx.Response:
+            captured["content"] = kwargs.get("content")
+            captured["headers"] = kwargs.get("headers")
+            return _mock_response(200, {"data": {"status": "completed"}})
+
+        monkeypatch.setattr(httpx, "post", mock_post)
+        ack("https://api.posthook.io/ack/token123")
+
+        assert captured["content"] is None
+        assert captured["headers"] == {}
+
+
+# ─── Sync nack() ────────────────────────────────────────────────────
+
+
+class TestNackSync:
+    def test_success_applied(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(200, {"data": {"status": "nacked"}}),
+        )
+        result = nack("https://api.posthook.io/nack/token123")
+        assert result == CallbackResult(applied=True, status="nacked")
+
+    def test_success_not_applied(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(200, {"data": {"status": "completed"}}),
+        )
+        result = nack("https://api.posthook.io/nack/token123")
+        assert result == CallbackResult(applied=False, status="completed")
+
+    def test_404_not_found(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(404),
+        )
+        result = nack("https://api.posthook.io/nack/token123")
+        assert result == CallbackResult(applied=False, status="not_found")
+
+    def test_409_conflict(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(409),
+        )
+        result = nack("https://api.posthook.io/nack/token123")
+        assert result == CallbackResult(applied=False, status="conflict")
+
+    def test_410_raises_callback_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "post",
+            lambda url, **kw: _mock_response(410, text="gone"),
+        )
+        with pytest.raises(CallbackError, match="nack failed: 410"):
+            nack("https://api.posthook.io/nack/token123")
+
+
+# ─── Async ack/nack ─────────────────────────────────────────────────
+
+
+class _MockAsyncClient:
+    """Replaces httpx.AsyncClient for async tests."""
+
+    def __init__(self, handler):
+        self._handler = handler
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        pass
+
+    async def post(self, url, **kwargs):
+        return self._handler(url, **kwargs)
+
+
+class TestAsyncAck:
+    async def test_success_applied(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "AsyncClient",
+            lambda **kw: _MockAsyncClient(
+                lambda url, **kw: _mock_response(200, {"data": {"status": "completed"}}),
+            ),
+        )
+        result = await async_ack("https://api.posthook.io/ack/token123")
+        assert result == CallbackResult(applied=True, status="completed")
+
+    async def test_410_raises_callback_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "AsyncClient",
+            lambda **kw: _MockAsyncClient(
+                lambda url, **kw: _mock_response(410, text="gone"),
+            ),
+        )
+        with pytest.raises(CallbackError, match="ack failed: 410"):
+            await async_ack("https://api.posthook.io/ack/token123")
+
+    async def test_500_raises_callback_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "AsyncClient",
+            lambda **kw: _MockAsyncClient(
+                lambda url, **kw: _mock_response(500, text="boom"),
+            ),
+        )
+        with pytest.raises(CallbackError, match="ack failed: 500"):
+            await async_ack("https://api.posthook.io/ack/token123")
+
+
+class TestAsyncNack:
+    async def test_success_applied(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "AsyncClient",
+            lambda **kw: _MockAsyncClient(
+                lambda url, **kw: _mock_response(200, {"data": {"status": "nacked"}}),
+            ),
+        )
+        result = await async_nack("https://api.posthook.io/nack/token123")
+        assert result == CallbackResult(applied=True, status="nacked")
+
+    async def test_409_conflict(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "AsyncClient",
+            lambda **kw: _MockAsyncClient(
+                lambda url, **kw: _mock_response(409),
+            ),
+        )
+        result = await async_nack("https://api.posthook.io/nack/token123")
+        assert result == CallbackResult(applied=False, status="conflict")
+
+    async def test_410_raises_callback_error(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            httpx, "AsyncClient",
+            lambda **kw: _MockAsyncClient(
+                lambda url, **kw: _mock_response(410, text="gone"),
+            ),
+        )
+        with pytest.raises(CallbackError, match="nack failed: 410"):
+            await async_nack("https://api.posthook.io/nack/token123")
+
+
+# ─── Importability ───────────────────────────────────────────────────
+
+
+class TestExports:
+    def test_callback_result_importable(self) -> None:
+        assert hasattr(posthook, "CallbackResult")
+
+    def test_callback_error_importable(self) -> None:
+        assert hasattr(posthook, "CallbackError")
+
+    def test_ack_importable(self) -> None:
+        assert hasattr(posthook, "ack")
+        assert hasattr(posthook, "nack")
+        assert hasattr(posthook, "async_ack")
+        assert hasattr(posthook, "async_nack")

{posthook_python-1.0.0 → posthook_python-1.1.0}/tests/test_signatures.py

@@ -204,3 +204,32 @@ class TestCreateSignatures:
     def test_importable_from_package(self) -> None:
         assert hasattr(posthook, "create_signatures")
         assert posthook.create_signatures is create_signatures
+
+
+class TestCallbackHeaders:
+    """Test that parse_delivery extracts ack/nack URLs from headers."""
+
+    def test_both_headers_present(self) -> None:
+        svc = SignaturesService("ph_sk_test")
+        body, headers = _make_delivery()
+        headers["Posthook-Ack-URL"] = "https://api.posthook.io/ack/token123"
+        headers["Posthook-Nack-URL"] = "https://api.posthook.io/nack/token123"
+        delivery = svc.parse_delivery(body, headers)
+        assert delivery.ack_url == "https://api.posthook.io/ack/token123"
+        assert delivery.nack_url == "https://api.posthook.io/nack/token123"
+
+    def test_no_headers(self) -> None:
+        svc = SignaturesService("ph_sk_test")
+        body, headers = _make_delivery()
+        delivery = svc.parse_delivery(body, headers)
+        assert delivery.ack_url is None
+        assert delivery.nack_url is None
+
+    def test_only_ack_header(self) -> None:
+        """When only one header is present, both should be None."""
+        svc = SignaturesService("ph_sk_test")
+        body, headers = _make_delivery()
+        headers["Posthook-Ack-URL"] = "https://api.posthook.io/ack/token123"
+        delivery = svc.parse_delivery(body, headers)
+        assert delivery.ack_url is None
+        assert delivery.nack_url is None

posthook_python-1.0.0/src/posthook/_version.py

@@ -1 +0,0 @@
-VERSION = "1.0.0"