Execution and Webhooks

import time
from typing import Optional
from altscore import AltScore
 
def poll_execution_status(
    alt_client: AltScore,
    execution_id: str,
    max_wait_seconds: int = 300,
    initial_interval: float = 1.0,
    max_interval: float = 30.0,
    backoff_multiplier: float = 1.5
) -> dict:
    """
    Poll for execution completion with exponential backoff.
 
    Args:
        alt_client: Initialized AltScore client
        execution_id: The execution ID to poll
        max_wait_seconds: Maximum time to wait for completion
        initial_interval: Starting poll interval in seconds
        max_interval: Maximum poll interval in seconds
        backoff_multiplier: Factor to increase interval each poll
 
    Returns:
        The completed execution result
 
    Raises:
        TimeoutError: If execution doesn't complete in time
        Exception: If execution fails
    """
    start_time = time.time()
    interval = initial_interval
 
    while time.time() - start_time < max_wait_seconds:
        # Get current status
        execution = alt_client.borrower_central.executions.retrieve(execution_id)
 
        if execution.status == "completed":
            return execution.output
 
        if execution.status == "failed":
            raise Exception(
                f"Execution failed: {execution.error_message}"
            )
 
        if execution.status == "cancelled":
            raise Exception("Execution was cancelled")
 
        # Wait before next poll with exponential backoff
        time.sleep(interval)
        interval = min(interval * backoff_multiplier, max_interval)
 
    raise TimeoutError(
        f"Execution {execution_id} did not complete within {max_wait_seconds}s"
    )
 
 
# Usage example
alt_client = AltScore(
    client_id="your-client-id",
    client_secret="your-client-secret",
    environment="production"
)
 
# Start async execution
result = alt_client.borrower_central.workflows.execute(
    alias="credit-decision",
    version="v1",
    input_data={"borrower_id": "brw_123"},
    sync=False  # Async execution
)
 
# Poll for completion
try:
    output = poll_execution_status(
        alt_client,
        result.execution_id,
        max_wait_seconds=120
    )
    print(f"Decision: {output['decision']}")
except TimeoutError:
    print("Execution taking too long, consider checking manually")
except Exception as e:
    print(f"Execution failed: {e}")

from fastapi import FastAPI, Request, HTTPException
from svix.webhooks import Webhook, WebhookVerificationError
 
app = FastAPI()
WEBHOOK_SECRET = "whsec_..."  # Settings > Webhooks
 
@app.post("/webhooks/altscore")
async def handle_altscore_webhook(request: Request):
    payload = await request.body()
    try:
        event = Webhook(WEBHOOK_SECRET).verify(payload, dict(request.headers))
    except WebhookVerificationError:
        raise HTTPException(status_code=401, detail="Invalid signature")
 
    if event["event"] == "bc.execution.completed":
        execution = event["data"]["entity"]
 
        if execution["isSuccess"]:
            await process_credit_decision(
                execution_id=execution["executionId"],
                status=execution["status"],
            )
        else:
            await handle_execution_failure(execution_id=execution["executionId"])
 
    return {"status": "received"}
 
async def process_credit_decision(execution_id: str, status: str):
    # Your business logic here
    pass
 
async def handle_execution_failure(execution_id: str):
    # Your error handling logic here
    pass

from altscore import AltScore
from typing import Optional
import logging
 
logger = logging.getLogger(__name__)
 
class WorkflowExecutionManager:
    """Manages workflow execution with error recovery."""
 
    def __init__(self, alt_client: AltScore):
        self.client = alt_client
 
    def execute_with_retry(
        self,
        alias: str,
        version: str,
        input_data: dict,
        max_retries: int = 3,
        retry_on_failure: bool = True
    ) -> dict:
        """
        Execute workflow with automatic retry on transient failures.
 
        Args:
            alias: Workflow alias
            version: Workflow version
            input_data: Workflow input
            max_retries: Maximum retry attempts
            retry_on_failure: Whether to retry failed executions
 
        Returns:
            Execution output on success
        """
        last_error = None
 
        for attempt in range(max_retries):
            try:
                # Execute workflow
                result = self.client.borrower_central.workflows.execute(
                    alias=alias,
                    version=version,
                    input_data=input_data,
                    sync=True
                )
 
                if result.is_success:
                    return result.output
 
                # Check if error is retryable
                if not retry_on_failure or not self._is_retryable_error(result):
                    raise ExecutionError(
                        f"Workflow failed: {result.error_message}",
                        execution_id=result.execution_id,
                        error_code=result.status_code
                    )
 
                last_error = result.error_message
                logger.warning(
                    f"Attempt {attempt + 1} failed: {last_error}, retrying..."
                )
 
            except ConnectionError as e:
                last_error = str(e)
                logger.warning(
                    f"Connection error on attempt {attempt + 1}: {e}"
                )
 
        raise ExecutionError(
            f"Workflow failed after {max_retries} attempts: {last_error}"
        )
 
    def _is_retryable_error(self, result) -> bool:
        """Determine if an error should trigger a retry."""
        retryable_codes = [
            "EXTERNAL_SERVICE_ERROR",
            "TIMEOUT",
            "CONNECTION_ERROR",
            "RATE_LIMITED"
        ]
        return result.error_code in retryable_codes
 
    def recover_failed_batch(
        self,
        batch_id: str,
        retry_mode: str = "failed_items"
    ) -> str:
        """
        Recover a failed batch by retrying failed items.
 
        Args:
            batch_id: The batch execution ID
            retry_mode: One of 'failed_items', 'unsuccessful_sources_items',
                       'failed_and_unsuccessful_sources_items'
 
        Returns:
            New batch ID for the retry
        """
        # Get batch status
        batch = self.client.borrower_central.execution_batches.retrieve(batch_id)
 
        if batch.status not in ["complete", "post_processing_failed"]:
            raise ValueError(
                f"Cannot recover batch in status: {batch.status}"
            )
 
        summary = batch.state.batch_items_executions_summary
 
        if retry_mode == "failed_items" and summary.failed == 0:
            logger.info("No failed items to retry")
            return batch_id
 
        # Retry failed items
        retry_result = self.client.borrower_central.execution_batches.retry(
            batch_id=batch_id,
            retry_mode=retry_mode,
            use_previous_inputs=True
        )
 
        logger.info(
            f"Batch retry started: {retry_result.execution_batch_id}"
        )
 
        return retry_result.execution_batch_id
 
 
class ExecutionError(Exception):
    """Custom exception for workflow execution failures."""
 
    def __init__(
        self,
        message: str,
        execution_id: Optional[str] = None,
        error_code: Optional[str] = None
    ):
        super().__init__(message)
        self.execution_id = execution_id
        self.error_code = error_code
 
 
# Usage example
alt_client = AltScore(
    client_id="your-client-id",
    client_secret="your-client-secret",
    environment="production"
)
 
manager = WorkflowExecutionManager(alt_client)
 
try:
    output = manager.execute_with_retry(
        alias="credit-decision",
        version="v1",
        input_data={"borrower_id": "brw_123"},
        max_retries=3
    )
    print(f"Decision: {output['decision']}")
except ExecutionError as e:
    print(f"Execution failed: {e}")
    if e.execution_id:
        print(f"Check execution: {e.execution_id}")