hookbase 2.5.0__tar.gz → 2.7.0__tar.gz

{hookbase-2.5.0 → hookbase-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hookbase
-Version: 2.5.0
+Version: 2.7.0
 Summary: Official Python SDK for the Hookbase webhook management platform
 Project-URL: Homepage, https://hookbase.app
 Project-URL: Documentation, https://www.hookbase.app/docs/send/sdk

{hookbase-2.5.0 → hookbase-2.7.0}/src/hookbase/_client.py

@@ -27,9 +27,15 @@ logger = logging.getLogger("hookbase")
 def _parse_error(status_code: int, body: dict[str, Any], request_id: str | None) -> APIError:
     error = body.get("error", body)
     if isinstance(error, str):
+        # This is the shape the real API actually sends: `error` is a plain string, with
+        # `code` and `details` (Zod's `.flatten()` shape: `{ fieldErrors, formErrors }`) as
+        # siblings at the top level of the body, not nested inside `error`.
         message = error
-        code = "unknown_error"
-        validation_errors = None
+        code = body.get("code", "unknown_error")
+        details = body.get("details")
+        validation_errors = (
+            details.get("fieldErrors") if isinstance(details, dict) else None
+        )
     elif isinstance(error, dict):
         message = error.get("message") or body.get("message") or f"API error: {status_code}"
         code = error.get("code", "unknown_error")

hookbase-2.7.0/src/hookbase/_version.py

@@ -0,0 +1 @@
+__version__ = "2.7.0"

{hookbase-2.5.0 → hookbase-2.7.0}/src/hookbase/errors.py

@@ -38,8 +38,11 @@ class APIError(HookbaseError):
     ) -> APIError:
         error = body.get("error", body)
         if isinstance(error, str):
+            # The real API always sends `error` as a plain string, with `code` and `details`
+            # (Zod's `.flatten()` shape: `{ fieldErrors, formErrors }`) as siblings of `error`
+            # at the top level of the body — never nested inside it.
             message = error
-            code = "unknown_error"
+            code = body.get("code", "unknown_error")
         elif isinstance(error, dict):
             message = error.get("message", f"API error: {status_code}")
             code = error.get("code", "unknown_error")
@@ -49,7 +52,11 @@ class APIError(HookbaseError):
 
         if status_code in (400, 422):
             validation_errors = None
-            if isinstance(error, dict):
+            if isinstance(error, str):
+                details = body.get("details")
+                if isinstance(details, dict):
+                    validation_errors = details.get("fieldErrors")
+            elif isinstance(error, dict):
                 validation_errors = error.get("validationErrors")
             return ValidationError(
                 message=message,

{hookbase-2.5.0 → hookbase-2.7.0}/src/hookbase/models/__init__.py

@@ -7,6 +7,7 @@ from .cron_jobs import (
     CreateCronJobParams,
     CronGroup,
     CronJob,
+    CronJobExecution,
     UpdateCronJobParams,
 )
 from .deliveries import (
@@ -26,8 +27,11 @@ from .destinations import (
     GCSConfig,
     HttpMethod,
     R2Config,
+    RateUnit,
     S3Config,
     TestResult,
+    Throttle,
+    ThrottleMode,
     UpdateDestinationParams,
 )
 from .dlq import (
@@ -120,6 +124,7 @@ __all__ = [
     "CreateCronJobParams",
     "CronGroup",
     "CronJob",
+    "CronJobExecution",
     "UpdateCronJobParams",
     # Deliveries
     "BulkReplayResult",
@@ -137,8 +142,11 @@ __all__ = [
     "GCSConfig",
     "HttpMethod",
     "R2Config",
+    "RateUnit",
     "S3Config",
     "TestResult",
+    "Throttle",
+    "ThrottleMode",
     "UpdateDestinationParams",
     # DLQ
     "DlqBulkDeleteResult",

{hookbase-2.5.0 → hookbase-2.7.0}/src/hookbase/models/cron_jobs.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
 import json
+from typing import Literal
 
 from pydantic import field_validator
 
 from ._base import HookbaseModel
 
+CronJobExecutionStatus = Literal["success", "failed"]
+
 
 class CronJob(HookbaseModel):
     id: str
@@ -15,15 +18,19 @@ class CronJob(HookbaseModel):
     url: str = ""
     method: str = "GET"
     headers: dict[str, str] | None = None
-    body: str | None = None
-    schedule: str = ""
+    payload: str | None = None
+    cron_expression: str = ""
     timezone: str = "UTC"
+    timeout_ms: int = 30000
     is_active: bool = True
     use_static_ip: bool = True
     group_id: str | None = None
     last_run_at: str | None = None
     next_run_at: str | None = None
-    last_status: str | None = None
+    consecutive_failures: int = 0
+    notify_on_failure: bool = False
+    notify_on_success: bool = False
+    notify_emails: str | None = None
     created_at: str = ""
     updated_at: str = ""
 
@@ -40,18 +47,29 @@ class CronJob(HookbaseModel):
         return v
 
 
+class CronJobExecution(HookbaseModel):
+    id: str
+    status: CronJobExecutionStatus = "success"
+    response_status: int | None = None
+    latency_ms: int = 0
+
+
 class CreateCronJobParams(HookbaseModel):
     name: str
     description: str | None = None
     url: str
     method: str | None = None
     headers: dict[str, str] | None = None
-    body: str | None = None
-    schedule: str
+    payload: str | None = None
+    cron_expression: str
     timezone: str | None = None
+    timeout_ms: int | None = None
     is_active: bool | None = None
     use_static_ip: bool | None = None
     group_id: str | None = None
+    notify_on_failure: bool | None = None
+    notify_on_success: bool | None = None
+    notify_emails: str | None = None
 
 
 class UpdateCronJobParams(HookbaseModel):
@@ -60,12 +78,16 @@ class UpdateCronJobParams(HookbaseModel):
     url: str | None = None
     method: str | None = None
     headers: dict[str, str] | None = None
-    body: str | None = None
-    schedule: str | None = None
+    payload: str | None = None
+    cron_expression: str | None = None
     timezone: str | None = None
+    timeout_ms: int | None = None
     is_active: bool | None = None
     use_static_ip: bool | None = None
     group_id: str | None = None
+    notify_on_failure: bool | None = None
+    notify_on_success: bool | None = None
+    notify_emails: str | None = None
 
 
 class CronGroup(HookbaseModel):

{hookbase-2.5.0 → hookbase-2.7.0}/src/hookbase/models/destinations.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from typing import Any, Literal
 
-from pydantic import field_validator
+from pydantic import field_validator, model_validator
 
 from ._base import HookbaseModel
 
@@ -13,6 +13,8 @@ DestinationType = Literal["http", "s3", "r2", "gcs", "azure_blob"]
 FileFormat = Literal["json", "jsonl"]
 PartitionBy = Literal["date", "hour", "source"]
 FieldMappingType = Literal["string", "number", "boolean", "timestamp", "json"]
+ThrottleMode = Literal["off", "rate", "concurrency"]
+RateUnit = Literal["second", "minute", "hour"]
 
 
 class FieldMapping(HookbaseModel):
@@ -57,6 +59,14 @@ class AzureBlobConfig(HookbaseModel):
     partition_by: PartitionBy | None = None
 
 
+class Throttle(HookbaseModel):
+    mode: ThrottleMode = "off"
+    rate_limit: int | None = None
+    rate_unit: RateUnit | None = None
+    max_concurrency: int | None = None
+    queue_limit: int | None = None
+
+
 class Destination(HookbaseModel):
     id: str
     organization_id: str | None = None
@@ -72,8 +82,7 @@ class Destination(HookbaseModel):
     timeout: int = 30
     retry_count: int = 3
     retry_interval: int = 60
-    rate_limit: int | None = None
-    rate_limit_window: int | None = None
+    throttle: Throttle | None = None
     is_active: bool = True
     use_static_ip: bool = True
     config: dict[str, Any] | None = None
@@ -85,6 +94,30 @@ class Destination(HookbaseModel):
     created_at: str = ""
     updated_at: str = ""
 
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_throttle(cls, data: Any) -> Any:
+        """Normalize the two response shapes the API uses for throttle data.
+
+        POST /api/destinations (create) and GET /api/destinations/export nest
+        throttle fields under a `throttle` object, but GET /api/destinations
+        (list) and GET /api/destinations/:id return them as flat top-level
+        `throttleMode`/`throttleRateLimit`/`throttleRateUnit`/
+        `throttleMaxConcurrency`/`throttleQueueLimit` fields (spread directly
+        from the DB row). Fold the flat shape into a nested `throttle` dict
+        so both response shapes populate the same field.
+        """
+        if isinstance(data, dict) and "throttle" not in data and "throttleMode" in data:
+            data = dict(data)
+            data["throttle"] = {
+                "mode": data.pop("throttleMode", None) or "off",
+                "rateLimit": data.pop("throttleRateLimit", None),
+                "rateUnit": data.pop("throttleRateUnit", None),
+                "maxConcurrency": data.pop("throttleMaxConcurrency", None),
+                "queueLimit": data.pop("throttleQueueLimit", None),
+            }
+        return data
+
     @field_validator("headers", mode="before")
     @classmethod
     def parse_headers(cls, v: Any) -> Any:
@@ -146,8 +179,7 @@ class CreateDestinationParams(HookbaseModel):
     timeout: int | None = None
     retry_count: int | None = None
     retry_interval: int | None = None
-    rate_limit: int | None = None
-    rate_limit_window: int | None = None
+    throttle: Throttle | None = None
     config: dict[str, Any] | None = None
     field_mapping: list[FieldMapping] | None = None
     use_static_ip: bool | None = None
@@ -166,8 +198,7 @@ class UpdateDestinationParams(HookbaseModel):
     timeout: int | None = None
     retry_count: int | None = None
     retry_interval: int | None = None
-    rate_limit: int | None = None
-    rate_limit_window: int | None = None
+    throttle: Throttle | None = None
     is_active: bool | None = None
     config: dict[str, Any] | None = None
     field_mapping: list[FieldMapping] | None = None

{hookbase-2.5.0 → hookbase-2.7.0}/src/hookbase/resources/cron_jobs.py

@@ -13,6 +13,7 @@ from ..models.cron_jobs import (
     CreateCronJobParams,
     CronGroup,
     CronJob,
+    CronJobExecution,
     UpdateCronJobParams,
 )
 from ._base import AsyncResource, SyncResource, _to_body
@@ -49,6 +50,11 @@ class CronJobs(SyncResource):
     def delete(self, id: str) -> None:
         self._request("DELETE", f"/api/cron/{id}")
 
+    def trigger(self, id: str) -> CronJobExecution:
+        resp = self._request("POST", f"/api/cron/{id}/trigger")
+        data = resp.get("execution", resp)
+        return self._parse(CronJobExecution, data)
+
     def list_groups(self) -> list[CronGroup]:
         resp = self._request("GET", "/api/cron-groups")
         items = resp.get("groups", resp.get("data", []))
@@ -92,6 +98,11 @@ class AsyncCronJobs(AsyncResource):
     async def delete(self, id: str) -> None:
         await self._request("DELETE", f"/api/cron/{id}")
 
+    async def trigger(self, id: str) -> CronJobExecution:
+        resp = await self._request("POST", f"/api/cron/{id}/trigger")
+        data = resp.get("execution", resp)
+        return self._parse(CronJobExecution, data)
+
     async def list_groups(self) -> list[CronGroup]:
         resp = await self._request("GET", "/api/cron-groups")
         items = resp.get("groups", resp.get("data", []))

hookbase-2.7.0/tests/resources/test_cron_jobs.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import pytest
+import respx
+
+from hookbase import Hookbase
+from hookbase.models import CronJob, CronJobExecution
+
+from ..conftest import make_paginated_response
+
+CRON_JOB_DATA = {
+    "id": "cron_1",
+    "organizationId": "org_1",
+    "groupId": None,
+    "name": "Nightly sync",
+    "description": None,
+    "cronExpression": "0 0 * * *",
+    "timezone": "UTC",
+    "url": "https://example.com/sync",
+    "method": "POST",
+    "headers": None,
+    "payload": None,
+    "timeoutMs": 30000,
+    "useStaticIp": False,
+    "isActive": True,
+    "notifyOnFailure": True,
+    "notifyOnSuccess": False,
+    "notifyEmails": None,
+    "consecutiveFailures": 0,
+    "lastRunAt": "2026-09-01T00:00:00Z",
+    "nextRunAt": "2026-09-02T00:00:00Z",
+    "createdAt": "2026-01-01T00:00:00Z",
+    "updatedAt": "2026-09-01T00:00:00Z",
+}
+
+
+@pytest.fixture
+def mock_api():
+    with respx.mock(base_url="https://api.hookbase.app") as mock:
+        yield mock
+
+
+@pytest.fixture
+def client(mock_api):
+    c = Hookbase(api_key="whr_test")
+    yield c
+    c.close()
+
+
+def test_list_cron_jobs_uses_real_field_names(mock_api, client):
+    # GET /api/cron sends cronExpression, timezone, nextRunAt, lastRunAt and
+    # consecutiveFailures -- not the old, fabricated "schedule"/"lastStatus" fields.
+    mock_api.get("/api/cron").respond(200, json=make_paginated_response(
+        [CRON_JOB_DATA], data_key="cronJobs", total=1,
+    ))
+    page = client.cron_jobs.list()
+    assert len(page) == 1
+    job = page.data[0]
+    assert isinstance(job, CronJob)
+    assert job.cron_expression == "0 0 * * *"
+    assert job.next_run_at == "2026-09-02T00:00:00Z"
+    assert job.last_run_at == "2026-09-01T00:00:00Z"
+    assert job.consecutive_failures == 0
+    assert job.payload is None
+    assert not hasattr(job, "last_status")
+    assert not hasattr(job, "schedule")
+
+
+def test_get_cron_job_uses_real_field_names(mock_api, client):
+    mock_api.get("/api/cron/cron_1").respond(200, json={"cronJob": CRON_JOB_DATA})
+    job = client.cron_jobs.get("cron_1")
+    assert job.cron_expression == "0 0 * * *"
+    assert job.timeout_ms == 30000
+    assert job.notify_on_failure is True
+    assert job.notify_on_success is False
+    assert job.consecutive_failures == 0
+
+
+def test_create_cron_job(mock_api, client):
+    mock_api.post("/api/cron").respond(200, json={"cronJob": CRON_JOB_DATA})
+    job = client.cron_jobs.create({
+        "name": "Nightly sync",
+        "url": "https://example.com/sync",
+        "cron_expression": "0 0 * * *",
+        "payload": '{"foo": "bar"}',
+    })
+    assert isinstance(job, CronJob)
+    assert job.cron_expression == "0 0 * * *"
+
+
+def test_update_cron_job(mock_api, client):
+    mock_api.patch("/api/cron/cron_1").respond(200, json={"success": True})
+    client.cron_jobs.update("cron_1", {"cron_expression": "*/5 * * * *", "payload": "{}"})
+
+
+def test_delete_cron_job(mock_api, client):
+    mock_api.delete("/api/cron/cron_1").respond(200, json={"success": True})
+    client.cron_jobs.delete("cron_1")
+
+
+def test_trigger_cron_job_calls_trigger_endpoint(mock_api, client):
+    route = mock_api.post("/api/cron/cron_1/trigger").respond(200, json={
+        "execution": {
+            "id": "exec_1",
+            "status": "success",
+            "responseStatus": 200,
+            "latencyMs": 142,
+        }
+    })
+    result = client.cron_jobs.trigger("cron_1")
+    assert route.called
+    assert isinstance(result, CronJobExecution)
+    assert result.id == "exec_1"
+    assert result.status == "success"
+    assert result.response_status == 200
+    assert result.latency_ms == 142
+
+
+def test_trigger_cron_job_failed_execution(mock_api, client):
+    mock_api.post("/api/cron/cron_1/trigger").respond(200, json={
+        "execution": {
+            "id": "exec_2",
+            "status": "failed",
+            "responseStatus": None,
+            "latencyMs": 30000,
+        }
+    })
+    result = client.cron_jobs.trigger("cron_1")
+    assert result.status == "failed"
+    assert result.response_status is None
+
+
+async def test_async_list_cron_jobs(mock_api):
+    from hookbase import AsyncHookbase
+
+    mock_api.get("/api/cron").respond(200, json=make_paginated_response(
+        [CRON_JOB_DATA], data_key="cronJobs", total=1,
+    ))
+    client = AsyncHookbase(api_key="whr_test")
+    page = await client.cron_jobs.list()
+    assert page.data[0].cron_expression == "0 0 * * *"
+    await client.close()
+
+
+async def test_async_trigger_cron_job(mock_api):
+    from hookbase import AsyncHookbase
+
+    mock_api.post("/api/cron/cron_1/trigger").respond(200, json={
+        "execution": {
+            "id": "exec_1",
+            "status": "success",
+            "responseStatus": 200,
+            "latencyMs": 99,
+        }
+    })
+    client = AsyncHookbase(api_key="whr_test")
+    result = await client.cron_jobs.trigger("cron_1")
+    assert isinstance(result, CronJobExecution)
+    assert result.latency_ms == 99
+    await client.close()

{hookbase-2.5.0 → hookbase-2.7.0}/tests/resources/test_destinations.py

@@ -4,7 +4,14 @@ import pytest
 import respx
 
 from hookbase import Hookbase
-from hookbase.models import Destination, FieldMapping, TestResult
+from hookbase.models import (
+    CreateDestinationParams,
+    Destination,
+    FieldMapping,
+    TestResult,
+    Throttle,
+    UpdateDestinationParams,
+)
 
 from ..conftest import make_paginated_response
 
@@ -183,6 +190,87 @@ def test_destination_without_type_defaults():
     assert dest.field_mapping is None
 
 
+def test_throttle_model():
+    throttle = Throttle(mode="rate", rate_limit=10, rate_unit="minute")
+    assert throttle.mode == "rate"
+    assert throttle.rate_limit == 10
+    assert throttle.rate_unit == "minute"
+    assert throttle.max_concurrency is None
+    assert throttle.queue_limit is None
+
+    default_throttle = Throttle()
+    assert default_throttle.mode == "off"
+
+
+def test_create_destination_response_nests_throttle(mock_api, client):
+    """POST /api/destinations nests throttle fields under `throttle`."""
+    data = {
+        **DEST_DATA,
+        "throttle": {
+            "mode": "rate",
+            "rateLimit": 100,
+            "rateUnit": "minute",
+            "maxConcurrency": None,
+            "queueLimit": 50,
+        },
+    }
+    mock_api.post("/api/destinations").respond(200, json={"destination": data})
+    dest = client.destinations.create({"name": "Backend", "url": "https://example.com/webhooks"})
+    assert dest.throttle is not None
+    assert dest.throttle.mode == "rate"
+    assert dest.throttle.rate_limit == 100
+    assert dest.throttle.rate_unit == "minute"
+    assert dest.throttle.max_concurrency is None
+    assert dest.throttle.queue_limit == 50
+
+
+def test_get_destination_response_has_flat_throttle_fields(mock_api, client):
+    """GET /api/destinations/:id returns throttle fields flat (spread from the
+    DB row) rather than nested under `throttle`; the model must normalize
+    this into the same `throttle` field used by the create/export shape."""
+    data = {
+        **DEST_DATA,
+        "throttleMode": "concurrency",
+        "throttleRateLimit": None,
+        "throttleRateUnit": None,
+        "throttleMaxConcurrency": 5,
+        "throttleQueueLimit": None,
+    }
+    mock_api.get("/api/destinations/dst_1").respond(200, json={"destination": data})
+    dest = client.destinations.get("dst_1")
+    assert dest.throttle is not None
+    assert dest.throttle.mode == "concurrency"
+    assert dest.throttle.max_concurrency == 5
+    assert dest.throttle.rate_limit is None
+
+
+def test_destination_without_throttle_data():
+    dest = Destination(**DEST_DATA)
+    assert dest.throttle is None
+
+
+def test_create_destination_params_throttle_serializes_camelcase():
+    params = CreateDestinationParams(
+        name="Backend",
+        url="https://example.com/webhooks",
+        throttle=Throttle(mode="rate", rate_limit=10, rate_unit="minute"),
+    )
+    body = params.model_dump(by_alias=True, exclude_none=True)
+    assert body["throttle"] == {"mode": "rate", "rateLimit": 10, "rateUnit": "minute"}
+
+
+def test_update_destination_params_throttle_serializes_camelcase():
+    params = UpdateDestinationParams(
+        throttle=Throttle(mode="concurrency", max_concurrency=25, queue_limit=100),
+    )
+    body = params.model_dump(by_alias=True, exclude_none=True)
+    assert body["throttle"] == {
+        "mode": "concurrency",
+        "maxConcurrency": 25,
+        "queueLimit": 100,
+    }
+
+
 def test_test_destination(mock_api, client):
     mock_api.post("/api/destinations/dst_1/test").respond(200, json={
         "success": True, "statusCode": 200, "duration": 150.5,

{hookbase-2.5.0 → hookbase-2.7.0}/tests/test_errors.py

@@ -30,16 +30,17 @@ def client(mock_api):
 
 def test_401_raises_authentication_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
-        401, json={"error": {"message": "Invalid API key"}}
+        401, json={"error": "Invalid API key", "code": "authentication_error"}
     )
     with pytest.raises(AuthenticationError) as exc_info:
         client.sources.get("src_1")
     assert exc_info.value.status_code == 401
+    assert str(exc_info.value) == "Invalid API key"
 
 
 def test_403_raises_forbidden_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
-        403, json={"error": {"message": "Forbidden"}}
+        403, json={"error": "Forbidden", "code": "forbidden"}
     )
     with pytest.raises(ForbiddenError):
         client.sources.get("src_1")
@@ -47,7 +48,7 @@ def test_403_raises_forbidden_error(mock_api, client):
 
 def test_404_raises_not_found_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
-        404, json={"error": {"message": "Not found"}}
+        404, json={"error": "Not found", "code": "not_found"}
     )
     with pytest.raises(NotFoundError):
         client.sources.get("src_1")
@@ -56,17 +57,24 @@ def test_404_raises_not_found_error(mock_api, client):
 def test_400_raises_validation_error(mock_api, client):
     mock_api.post("/api/sources").respond(
         400,
-        json={"error": {"message": "Name is required",
-                         "validationErrors": {"name": ["required"]}}},
+        json={
+            "error": "Name is required",
+            "code": "validation_error",
+            "details": {
+                "fieldErrors": {"name": ["required"]},
+                "formErrors": [],
+            },
+        },
     )
     with pytest.raises(ValidationError) as exc_info:
         client.sources.create({"name": ""})
     assert exc_info.value.validation_errors == {"name": ["required"]}
+    assert str(exc_info.value) == "Name is required"
 
 
 def test_409_raises_conflict_error(mock_api, client):
     mock_api.post("/api/sources").respond(
-        409, json={"error": {"message": "Slug already exists"}}
+        409, json={"error": "Slug already exists", "code": "conflict"}
     )
     with pytest.raises(ConflictError):
         client.sources.create({"name": "test", "slug": "existing"})
@@ -75,7 +83,7 @@ def test_409_raises_conflict_error(mock_api, client):
 def test_429_raises_rate_limit_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
         429,
-        json={"error": {"message": "Too many requests"}},
+        json={"error": "Too many requests", "code": "rate_limit_exceeded"},
         headers={"retry-after": "30"},
     )
     with pytest.raises(RateLimitError) as exc_info:
@@ -85,16 +93,45 @@ def test_429_raises_rate_limit_error(mock_api, client):
 
 def test_500_raises_api_error(mock_api, client):
     mock_api.get("/api/sources/src_1").respond(
-        500, json={"error": {"message": "Internal error"}}
+        500, json={"error": "Internal error", "code": "internal_error"}
     )
     with pytest.raises(APIError) as exc_info:
         client.sources.get("src_1")
     assert exc_info.value.status_code == 500
+    # The real API's `code` is a body-level sibling of `error`, not nested inside it —
+    # make sure it's actually read rather than falling back to the generic default.
+    assert exc_info.value.code == "internal_error"
+
+
+def test_error_code_falls_back_to_default_when_absent(mock_api, client):
+    mock_api.get("/api/sources/src_1").respond(500, json={"error": "Internal error"})
+    with pytest.raises(APIError) as exc_info:
+        client.sources.get("src_1")
+    assert exc_info.value.code == "unknown_error"
 
 
 def test_error_from_response_string_error():
-    err = APIError.from_response(500, {"error": "Server error"})
+    err = APIError.from_response(500, {"error": "Server error", "code": "server_error"})
     assert str(err) == "Server error"
+    assert err.code == "server_error"
+
+
+def test_error_from_response_string_error_default_code():
+    err = APIError.from_response(500, {"error": "Server error"})
+    assert err.code == "unknown_error"
+
+
+def test_error_from_response_validation_details():
+    err = APIError.from_response(
+        400,
+        {
+            "error": "Name is required",
+            "code": "validation_error",
+            "details": {"fieldErrors": {"name": ["required"]}},
+        },
+    )
+    assert isinstance(err, ValidationError)
+    assert err.validation_errors == {"name": ["required"]}
 
 
 def test_error_from_response_dict_error():
@@ -102,3 +139,4 @@ def test_error_from_response_dict_error():
         500, {"error": {"message": "Detailed error", "code": "server_error"}},
     )
     assert str(err) == "Detailed error"
+    assert err.code == "server_error"

hookbase-2.5.0/src/hookbase/_version.py

@@ -1 +0,0 @@
-__version__ = "2.5.0"