adcp 2.12.2__py3-none-any.whl → 2.14.0__py3-none-any.whl

adcp/__init__.py

@@ -101,6 +101,7 @@ from adcp.types import (
     ListCreativeFormatsResponse,
     ListCreativesRequest,
     ListCreativesResponse,
+    McpWebhookPayload,
     MediaBuy,
     MediaBuyStatus,
     Package,
@@ -178,8 +179,14 @@ from adcp.validation import (
     validate_product,
     validate_publisher_properties_item,
 )
+from adcp.webhooks import (
+    create_a2a_webhook_payload,
+    create_mcp_webhook_payload,
+    extract_webhook_result_data,
+    get_adcp_signed_headers_for_webhook,
+)
 
-__version__ = "2.12.2"
+__version__ = "2.14.0"
 
 
 def get_adcp_version() -> str:
@@ -215,6 +222,12 @@ __all__ = [
     "TaskResult",
     "TaskStatus",
     "WebhookMetadata",
+    # Webhook utilities
+    "create_mcp_webhook_payload",
+    "create_a2a_webhook_payload",
+    "get_adcp_signed_headers_for_webhook",
+    "extract_webhook_result_data",
+    "McpWebhookPayload",
     # Common request/response types (re-exported for convenience)
     "CreateMediaBuyRequest",
     "CreateMediaBuyResponse",

adcp/adagents.py

@@ -478,12 +478,19 @@ def get_all_tags(adagents_data: dict[str, Any]) -> set[str]:
 def get_properties_by_agent(adagents_data: dict[str, Any], agent_url: str) -> list[dict[str, Any]]:
     """Get all properties authorized for a specific agent.
 
+    Handles all authorization types per the AdCP specification:
+    - inline_properties: Properties defined directly in the agent's properties array
+    - property_ids: Filter top-level properties by property_id
+    - property_tags: Filter top-level properties by tags
+    - publisher_properties: References properties from other publisher domains
+      (returns the selector objects, not resolved properties)
+
     Args:
         adagents_data: Parsed adagents.json data
         agent_url: URL of the agent to filter by
 
     Returns:
-        List of properties for the specified agent (empty if agent not found or no properties)
+        List of properties for the specified agent (empty if agent not found)
 
     Raises:
         AdagentsValidationError: If adagents_data is malformed
@@ -495,6 +502,11 @@ def get_properties_by_agent(adagents_data: dict[str, Any], agent_url: str) -> li
     if not isinstance(authorized_agents, list):
         raise AdagentsValidationError("adagents.json must have 'authorized_agents' array")
 
+    # Get top-level properties for reference-based authorization types
+    top_level_properties = adagents_data.get("properties", [])
+    if not isinstance(top_level_properties, list):
+        top_level_properties = []
+
     # Normalize the agent URL for comparison
     normalized_agent_url = normalize_url(agent_url)
 
@@ -510,12 +522,44 @@ def get_properties_by_agent(adagents_data: dict[str, Any], agent_url: str) -> li
         if normalize_url(agent_url_from_json) != normalized_agent_url:
             continue
 
-        # Found the agent - return their properties
-        properties = agent.get("properties", [])
-        if not isinstance(properties, list):
-            return []
-
-        return [p for p in properties if isinstance(p, dict)]
+        # Found the agent - determine authorization type
+        authorization_type = agent.get("authorization_type", "")
+
+        # Handle inline_properties (properties array directly on agent)
+        if authorization_type == "inline_properties" or "properties" in agent:
+            properties = agent.get("properties", [])
+            if not isinstance(properties, list):
+                return []
+            return [p for p in properties if isinstance(p, dict)]
+
+        # Handle property_ids (filter top-level properties by property_id)
+        if authorization_type == "property_ids":
+            authorized_ids = set(agent.get("property_ids", []))
+            return [
+                p
+                for p in top_level_properties
+                if isinstance(p, dict) and p.get("property_id") in authorized_ids
+            ]
+
+        # Handle property_tags (filter top-level properties by tags)
+        if authorization_type == "property_tags":
+            authorized_tags = set(agent.get("property_tags", []))
+            return [
+                p
+                for p in top_level_properties
+                if isinstance(p, dict) and set(p.get("tags", [])) & authorized_tags
+            ]
+
+        # Handle publisher_properties (cross-domain references)
+        # Returns the selector objects; caller must resolve against other domains
+        if authorization_type == "publisher_properties":
+            publisher_props = agent.get("publisher_properties", [])
+            if not isinstance(publisher_props, list):
+                return []
+            return [p for p in publisher_props if isinstance(p, dict)]
+
+        # No recognized authorization type - return empty
+        return []
 
     return []
 
@@ -544,8 +588,8 @@ class AuthorizationContext:
             if not isinstance(prop, dict):
                 continue
 
-            # Extract property ID
-            prop_id = prop.get("id")
+            # Extract property ID (per AdCP v2 schema, the field is "property_id")
+            prop_id = prop.get("property_id")
             if prop_id and isinstance(prop_id, str):
                 self.property_ids.append(prop_id)
 

adcp/client.py

@@ -11,6 +11,7 @@ from collections.abc import Callable
 from datetime import datetime, timezone
 from typing import Any
 
+from a2a.types import Task, TaskStatusUpdateEvent
 from pydantic import BaseModel
 
 from adcp.exceptions import ADCPWebhookSignatureError
@@ -45,7 +46,6 @@ from adcp.types import (
     SyncCreativesResponse,
     UpdateMediaBuyRequest,
     UpdateMediaBuyResponse,
-    WebhookPayload,
 )
 from adcp.types.core import (
     Activity,
@@ -55,6 +55,7 @@ from adcp.types.core import (
     TaskResult,
     TaskStatus,
 )
+from adcp.types.generated_poc.core.async_response_data import AdcpAsyncResponseData
 from adcp.utils.operation_id import create_operation_id
 
 logger = logging.getLogger(__name__)
@@ -811,13 +812,23 @@ class ADCPClient:
         """Async context manager exit."""
         await self.close()
 
-    def _verify_webhook_signature(self, payload: dict[str, Any], signature: str) -> bool:
+    def _verify_webhook_signature(
+        self, payload: dict[str, Any], signature: str, timestamp: str
+    ) -> bool:
         """
         Verify HMAC-SHA256 signature of webhook payload.
 
+        The verification algorithm matches get_adcp_signed_headers_for_webhook:
+        1. Constructs message as "{timestamp}.{json_payload}"
+        2. JSON-serializes payload with compact separators
+        3. UTF-8 encodes the message
+        4. HMAC-SHA256 signs with the shared secret
+        5. Compares against the provided signature (with "sha256=" prefix stripped)
+
         Args:
             payload: Webhook payload dict
-            signature: Signature to verify
+            signature: Signature to verify (with or without "sha256=" prefix)
+            timestamp: ISO 8601 timestamp from X-AdCP-Timestamp header
 
         Returns:
             True if signature is valid, False otherwise
@@ -825,22 +836,53 @@ class ADCPClient:
         if not self.webhook_secret:
             return True
 
-        payload_bytes = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")
+        # Strip "sha256=" prefix if present
+        if signature.startswith("sha256="):
+            signature = signature[7:]
+
+        # Serialize payload to JSON with consistent formatting (matches signing)
+        payload_bytes = json.dumps(payload, separators=(",", ":"), sort_keys=False).encode("utf-8")
+
+        # Construct signed message: timestamp.payload (matches get_adcp_signed_headers_for_webhook)
+        signed_message = f"{timestamp}.{payload_bytes.decode('utf-8')}"
+
+        # Generate expected signature
         expected_signature = hmac.new(
-            self.webhook_secret.encode("utf-8"), payload_bytes, hashlib.sha256
+            self.webhook_secret.encode("utf-8"), signed_message.encode("utf-8"), hashlib.sha256
         ).hexdigest()
 
         return hmac.compare_digest(signature, expected_signature)
 
-    def _parse_webhook_result(self, webhook: WebhookPayload) -> TaskResult[Any]:
+    def _parse_webhook_result(
+        self,
+        task_id: str,
+        task_type: str,
+        operation_id: str,
+        status: GeneratedTaskStatus,
+        result: Any,
+        timestamp: datetime | str,
+        message: str | None,
+        context_id: str | None,
+    ) -> TaskResult[AdcpAsyncResponseData]:
         """
-        Parse webhook payload into typed TaskResult based on task_type.
+        Parse webhook data into typed TaskResult based on task_type.
 
         Args:
-            webhook: Validated webhook payload
+            task_id: Unique identifier for this task
+            task_type: Task type from application routing (e.g., "get_products")
+            operation_id: Operation identifier from application routing
+            status: Current task status
+            result: Task-specific payload (AdCP response data)
+            timestamp: ISO 8601 timestamp when webhook was generated
+            message: Human-readable summary of task state
+            context_id: Session/conversation identifier
 
         Returns:
             TaskResult with task-specific typed response data
+
+        Note:
+            This method works with both MCP and A2A protocols by accepting
+            protocol-agnostic parameters rather than protocol-specific objects.
         """
         from adcp.utils.response_parser import parse_json_or_text
 
@@ -859,21 +901,20 @@ class ADCPClient:
         }
 
         # Handle completed tasks with result parsing
-
-        if webhook.status == GeneratedTaskStatus.completed and webhook.result is not None:
-            response_type = response_type_map.get(webhook.task_type.value)
+        if status == GeneratedTaskStatus.completed and result is not None:
+            response_type = response_type_map.get(task_type)
             if response_type:
                 try:
-                    parsed_result: Any = parse_json_or_text(webhook.result, response_type)
-                    return TaskResult[Any](
+                    parsed_result: Any = parse_json_or_text(result, response_type)
+                    return TaskResult[AdcpAsyncResponseData](
                         status=TaskStatus.COMPLETED,
                         data=parsed_result,
                         success=True,
                         metadata={
-                            "task_id": webhook.task_id,
-                            "operation_id": webhook.operation_id,
-                            "timestamp": webhook.timestamp,
-                            "message": webhook.message,
+                            "task_id": task_id,
+                            "operation_id": operation_id,
+                            "timestamp": timestamp,
+                            "message": message,
                         },
                     )
                 except ValueError as e:
@@ -881,8 +922,7 @@ class ADCPClient:
                     # Fall through to untyped result
 
         # Handle failed, input-required, or unparseable results
-        # Convert webhook status to core TaskStatus enum
-        # Map generated enum values to core enum values
+        # Convert status to core TaskStatus enum
         status_map = {
             GeneratedTaskStatus.completed: TaskStatus.COMPLETED,
             GeneratedTaskStatus.submitted: TaskStatus.SUBMITTED,
@@ -890,77 +930,341 @@ class ADCPClient:
             GeneratedTaskStatus.failed: TaskStatus.FAILED,
             GeneratedTaskStatus.input_required: TaskStatus.NEEDS_INPUT,
         }
-        task_status = status_map.get(webhook.status, TaskStatus.FAILED)
-
-        return TaskResult[Any](
+        task_status = status_map.get(status, TaskStatus.FAILED)
+
+        # Extract error message from result.errors if present
+        error_message: str | None = None
+        if result is not None and hasattr(result, "errors"):
+            errors = getattr(result, "errors", None)
+            if errors and len(errors) > 0:
+                first_error = errors[0]
+                if hasattr(first_error, "message"):
+                    error_message = first_error.message
+
+        return TaskResult[AdcpAsyncResponseData](
             status=task_status,
-            data=webhook.result,
-            success=webhook.status == GeneratedTaskStatus.completed,
-            error=webhook.error if isinstance(webhook.error, str) else None,
+            data=result,
+            success=status == GeneratedTaskStatus.completed,
+            error=error_message,
             metadata={
-                "task_id": webhook.task_id,
-                "operation_id": webhook.operation_id,
-                "timestamp": webhook.timestamp,
-                "message": webhook.message,
-                "context_id": webhook.context_id,
-                "progress": webhook.progress,
+                "task_id": task_id,
+                "operation_id": operation_id,
+                "timestamp": timestamp,
+                "message": message,
+                "context_id": context_id,
             },
         )
 
-    async def handle_webhook(
+    async def _handle_mcp_webhook(
         self,
         payload: dict[str, Any],
-        signature: str | None = None,
-    ) -> TaskResult[Any]:
+        task_type: str,
+        operation_id: str,
+        signature: str | None,
+        timestamp: str | None = None,
+    ) -> TaskResult[AdcpAsyncResponseData]:
         """
-        Handle incoming webhook and return typed result.
-
-        This method:
-        1. Verifies webhook signature (if provided)
-        2. Validates payload against WebhookPayload schema
-        3. Parses task-specific result data into typed response
-        4. Emits activity for monitoring
+        Handle MCP webhook delivered via HTTP POST.
 
         Args:
             payload: Webhook payload dict
-            signature: Optional HMAC-SHA256 signature for verification
+            task_type: Task type from application routing
+            operation_id: Operation identifier from application routing
+            signature: Optional HMAC-SHA256 signature for verification (X-AdCP-Signature header)
+            timestamp: Optional timestamp for signature verification (X-AdCP-Timestamp header)
 
         Returns:
             TaskResult with parsed task-specific response data
 
         Raises:
             ADCPWebhookSignatureError: If signature verification fails
-            ValidationError: If payload doesn't match WebhookPayload schema
-
-        Example:
-            >>> result = await client.handle_webhook(payload, signature)
-            >>> if result.success and isinstance(result.data, GetProductsResponse):
-            >>>     print(f"Found {len(result.data.products)} products")
+            ValidationError: If payload doesn't match McpWebhookPayload schema
         """
-        # Verify signature before processing
-        if signature and not self._verify_webhook_signature(payload, signature):
+        from adcp.types.generated_poc.core.mcp_webhook_payload import McpWebhookPayload
+
+        # Verify signature before processing (requires both signature and timestamp)
+        if (
+            signature
+            and timestamp
+            and not self._verify_webhook_signature(payload, signature, timestamp)
+        ):
             logger.warning(
                 f"Webhook signature verification failed for agent {self.agent_config.id}"
             )
             raise ADCPWebhookSignatureError("Invalid webhook signature")
 
-        # Validate and parse webhook payload
-        webhook = WebhookPayload.model_validate(payload)
+        # Validate and parse MCP webhook payload
+        webhook = McpWebhookPayload.model_validate(payload)
+
+        # Emit activity for monitoring
+        self._emit_activity(
+            Activity(
+                type=ActivityType.WEBHOOK_RECEIVED,
+                operation_id=operation_id,
+                agent_id=self.agent_config.id,
+                task_type=task_type,
+                timestamp=datetime.now(timezone.utc).isoformat(),
+                metadata={"payload": payload, "protocol": "mcp"},
+            )
+        )
+
+        # Extract fields and parse result
+        return self._parse_webhook_result(
+            task_id=webhook.task_id,
+            task_type=task_type,
+            operation_id=operation_id,
+            status=webhook.status,
+            result=webhook.result,
+            timestamp=webhook.timestamp,
+            message=webhook.message,
+            context_id=webhook.context_id,
+        )
+
+    async def _handle_a2a_webhook(
+        self, payload: Task | TaskStatusUpdateEvent, task_type: str, operation_id: str
+    ) -> TaskResult[AdcpAsyncResponseData]:
+        """
+        Handle A2A webhook delivered through Task or TaskStatusUpdateEvent.
+
+        Per A2A specification:
+        - Terminated statuses (completed, failed): Payload is Task with artifacts[].parts[]
+        - Intermediate statuses (working, input-required, submitted):
+        Payload is TaskStatusUpdateEvent with status.message.parts[]
+
+        Args:
+            payload: A2A Task or TaskStatusUpdateEvent object
+            task_type: Task type from application routing
+            operation_id: Operation identifier from application routing
+
+        Returns:
+            TaskResult with parsed task-specific response data
+
+        Note:
+            Signature verification is NOT applicable for A2A webhooks
+            as they arrive through authenticated A2A connections, not HTTP.
+        """
+        from a2a.types import DataPart, TextPart
+
+        adcp_data: Any = None
+        text_message: str | None = None
+        task_id: str
+        context_id: str | None
+        status_state: str
+        timestamp: datetime | str
+
+        # Type detection and extraction based on payload type
+        if isinstance(payload, TaskStatusUpdateEvent):
+            # Intermediate status: Extract from status.message.parts[]
+            task_id = payload.task_id
+            context_id = payload.context_id
+            status_state = payload.status.state if payload.status else "failed"
+            timestamp = (
+                payload.status.timestamp
+                if payload.status and payload.status.timestamp
+                else datetime.now(timezone.utc)
+            )
+
+            # Extract from status.message.parts[]
+            if payload.status and payload.status.message and payload.status.message.parts:
+                # Extract DataPart for structured AdCP payload
+                data_parts = [
+                    p.root for p in payload.status.message.parts if isinstance(p.root, DataPart)
+                ]
+                if data_parts:
+                    # Use last DataPart as authoritative
+                    last_data_part = data_parts[-1]
+                    adcp_data = last_data_part.data
+
+                    # Unwrap {"response": {...}} wrapper if present (ADK pattern)
+                    if isinstance(adcp_data, dict) and "response" in adcp_data:
+                        if len(adcp_data) == 1:
+                            adcp_data = adcp_data["response"]
+                        else:
+                            adcp_data = adcp_data["response"]
+
+                # Extract TextPart for human-readable message
+                for part in payload.status.message.parts:
+                    if isinstance(part.root, TextPart):
+                        text_message = part.root.text
+                        break
+
+        else:
+            # Terminated status (Task): Extract from artifacts[].parts[]
+            task_id = payload.id
+            context_id = payload.context_id
+            status_state = payload.status.state if payload.status else "failed"
+            timestamp = (
+                payload.status.timestamp
+                if payload.status and payload.status.timestamp
+                else datetime.now(timezone.utc)
+            )
+
+            # Extract from task.artifacts[].parts[]
+            # Following A2A spec: use last artifact, last DataPart is authoritative
+            if payload.artifacts:
+                # Use last artifact (most recent in streaming scenarios)
+                target_artifact = payload.artifacts[-1]
+
+                if target_artifact.parts:
+                    # Extract DataPart for structured AdCP payload
+                    data_parts = [
+                        p.root for p in target_artifact.parts if isinstance(p.root, DataPart)
+                    ]
+                    if data_parts:
+                        # Use last DataPart as authoritative
+                        last_data_part = data_parts[-1]
+                        adcp_data = last_data_part.data
+
+                        # Unwrap {"response": {...}} wrapper if present (ADK pattern)
+                        if isinstance(adcp_data, dict) and "response" in adcp_data:
+                            if len(adcp_data) == 1:
+                                adcp_data = adcp_data["response"]
+                            else:
+                                adcp_data = adcp_data["response"]
+
+                    # Extract TextPart for human-readable message
+                    for part in target_artifact.parts:
+                        if isinstance(part.root, TextPart):
+                            text_message = part.root.text
+                            break
+
+        # Map A2A status.state to GeneratedTaskStatus enum
+        status_map = {
+            "completed": GeneratedTaskStatus.completed,
+            "submitted": GeneratedTaskStatus.submitted,
+            "working": GeneratedTaskStatus.working,
+            "failed": GeneratedTaskStatus.failed,
+            "input-required": GeneratedTaskStatus.input_required,
+            "input_required": GeneratedTaskStatus.input_required,  # Handle both formats
+        }
+        mapped_status = status_map.get(status_state, GeneratedTaskStatus.failed)
 
         # Emit activity for monitoring
         self._emit_activity(
             Activity(
                 type=ActivityType.WEBHOOK_RECEIVED,
-                operation_id=webhook.operation_id or "unknown",
+                operation_id=operation_id,
                 agent_id=self.agent_config.id,
-                task_type=webhook.task_type.value,
+                task_type=task_type,
                 timestamp=datetime.now(timezone.utc).isoformat(),
-                metadata={"payload": payload},
+                metadata={
+                    "task_id": task_id,
+                    "protocol": "a2a",
+                    "payload_type": (
+                        "TaskStatusUpdateEvent"
+                        if isinstance(payload, TaskStatusUpdateEvent)
+                        else "Task"
+                    ),
+                },
             )
         )
 
-        # Parse and return typed result
-        return self._parse_webhook_result(webhook)
+        # Parse and return typed result by passing extracted fields directly
+        return self._parse_webhook_result(
+            task_id=task_id,
+            task_type=task_type,
+            operation_id=operation_id,
+            status=mapped_status,
+            result=adcp_data,
+            timestamp=timestamp,
+            message=text_message,
+            context_id=context_id,
+        )
+
+    async def handle_webhook(
+        self,
+        payload: dict[str, Any] | Task | TaskStatusUpdateEvent,
+        task_type: str,
+        operation_id: str,
+        signature: str | None = None,
+        timestamp: str | None = None,
+    ) -> TaskResult[AdcpAsyncResponseData]:
+        """
+        Handle incoming webhook and return typed result.
+
+        This method provides a unified interface for handling webhooks from both
+        MCP and A2A protocols:
+
+        - MCP Webhooks: HTTP POST with dict payload, optional HMAC signature
+        - A2A Webhooks: Task or TaskStatusUpdateEvent objects based on status
+
+        The method automatically detects the protocol type and routes to the
+        appropriate handler. Both protocols return a consistent TaskResult
+        structure with typed AdCP response data.
+
+        Args:
+            payload: Webhook payload - one of:
+                - dict[str, Any]: MCP webhook payload from HTTP POST
+                - Task: A2A webhook for terminated statuses (completed, failed)
+                - TaskStatusUpdateEvent: A2A webhook for intermediate statuses
+                  (working, input-required, submitted)
+            task_type: Task type from application routing (e.g., "get_products").
+                Applications should extract this from URL routing pattern:
+                /webhook/{task_type}/{agent_id}/{operation_id}
+            operation_id: Operation identifier from application routing.
+                Used to correlate webhook notifications with original task submission.
+            signature: Optional HMAC-SHA256 signature for MCP webhook verification
+                (X-AdCP-Signature header). Ignored for A2A webhooks.
+            timestamp: Optional timestamp for MCP webhook signature verification
+                (X-AdCP-Timestamp header). Required when signature is provided.
+
+        Returns:
+            TaskResult with parsed task-specific response data. The structure
+            is identical regardless of protocol.
+
+        Raises:
+            ADCPWebhookSignatureError: If MCP signature verification fails
+            ValidationError: If MCP payload doesn't match WebhookPayload schema
+
+        Note:
+            task_type and operation_id were deprecated from the webhook payload
+            per AdCP specification. Applications must extract these from URL
+            routing and pass them explicitly.
+
+        Examples:
+            MCP webhook (HTTP endpoint):
+            >>> @app.post("/webhook/{task_type}/{agent_id}/{operation_id}")
+            >>> async def webhook_handler(task_type: str, operation_id: str, request: Request):
+            >>>     payload = await request.json()
+            >>>     signature = request.headers.get("X-AdCP-Signature")
+            >>>     timestamp = request.headers.get("X-AdCP-Timestamp")
+            >>>     result = await client.handle_webhook(
+            >>>         payload, task_type, operation_id, signature, timestamp
+            >>>     )
+            >>>     if result.success:
+            >>>         print(f"Task completed: {result.data}")
+
+            A2A webhook with Task (terminated status):
+            >>> async def on_task_completed(task: Task):
+            >>>     # Extract task_type and operation_id from your app's task tracking
+            >>>     task_type = your_task_registry.get_type(task.id)
+            >>>     operation_id = your_task_registry.get_operation_id(task.id)
+            >>>     result = await client.handle_webhook(
+            >>>         task, task_type, operation_id
+            >>>     )
+            >>>     if result.success:
+            >>>         print(f"Task completed: {result.data}")
+
+            A2A webhook with TaskStatusUpdateEvent (intermediate status):
+            >>> async def on_task_update(event: TaskStatusUpdateEvent):
+            >>>     # Extract task_type and operation_id from your app's task tracking
+            >>>     task_type = your_task_registry.get_type(event.task_id)
+            >>>     operation_id = your_task_registry.get_operation_id(event.task_id)
+            >>>     result = await client.handle_webhook(
+            >>>         event, task_type, operation_id
+            >>>     )
+            >>>     if result.status == GeneratedTaskStatus.working:
+            >>>         print(f"Task still working: {result.metadata.get('message')}")
+        """
+        # Detect protocol type and route to appropriate handler
+        if isinstance(payload, (Task, TaskStatusUpdateEvent)):
+            # A2A webhook (Task or TaskStatusUpdateEvent)
+            return await self._handle_a2a_webhook(payload, task_type, operation_id)
+        else:
+            # MCP webhook (dict payload)
+            return await self._handle_mcp_webhook(
+                payload, task_type, operation_id, signature, timestamp
+            )
 
 
 class ADCPMultiAgentClient:

adcp/protocols/mcp.py

@@ -136,9 +136,7 @@ class MCPAdapter(ProtocolAdapter):
             and ("cancel scope" in exc_str or "async context" in exc_str)
         ) or (
             # HTTP errors during cleanup (if httpx is available)
-            HTTPX_AVAILABLE
-            and HTTPStatusError is not None
-            and isinstance(exc, HTTPStatusError)
+            HTTPX_AVAILABLE and HTTPStatusError is not None and isinstance(exc, HTTPStatusError)
         )
 
         if is_known_cleanup_error: