workflows.py

"""Composite execution workflows wiring risk and compliance controls."""

from __future__ import annotations

from dataclasses import dataclass
from typing import Iterable

from .compliance import ComplianceMonitor, ComplianceReport, ComplianceViolation
from .risk import LimitViolation, OrderRateExceeded, RiskManager


@dataclass(slots=True, frozen=True)
class OrderRequest:
    """Lightweight representation of an order for workflow evaluation."""

    symbol: str
    side: str
    quantity: float
    price: float


@dataclass(slots=True, frozen=True)
class OrderAssessment:
    """Outcome of running risk and compliance against a single order."""

    request: OrderRequest
    compliance_report: ComplianceReport
    risk_error: str | None = None

    @property
    def passed(self) -> bool:
        return not self.compliance_report.blocked and self.risk_error is None


@dataclass(slots=True, frozen=True)
class WorkflowAssessment:
    """Collection of order outcomes generated by :class:`RiskComplianceWorkflow`."""

    accepted: tuple[OrderAssessment, ...]
    rejected: tuple[OrderAssessment, ...]

    @property
    def compliance_reports(self) -> tuple[ComplianceReport, ...]:
        return tuple(
            assessment.compliance_report
            for assessment in (*self.accepted, *self.rejected)
        )

    @property
    def passed(self) -> bool:
        return not self.rejected


class RiskComplianceWorkflow:
    """Run compliance checks followed by risk validation for order batches."""

    def __init__(
        self, risk_manager: RiskManager, compliance_monitor: ComplianceMonitor
    ) -> None:
        self._risk = risk_manager
        self._compliance = compliance_monitor

    def evaluate(self, orders: Iterable[OrderRequest]) -> WorkflowAssessment:
        """Evaluate ``orders`` returning structured outcomes."""

        accepted: list[OrderAssessment] = []
        rejected: list[OrderAssessment] = []
        for order in orders:
            try:
                report = self._compliance.check(
                    order.symbol, order.quantity, order.price
                )
            except ComplianceViolation as exc:
                report = exc.report
                if report is None:
                    report = ComplianceReport(
                        symbol=order.symbol,
                        requested_quantity=order.quantity,
                        requested_price=order.price,
                        normalized_quantity=order.quantity,
                        normalized_price=order.price,
                        violations=(str(exc),),
                        blocked=True,
                    )
                rejected.append(OrderAssessment(order, report))
                continue
            assessment = OrderAssessment(request=order, compliance_report=report)
            if report.blocked:
                rejected.append(assessment)
                continue
            try:
                self._risk.validate_order(
                    order.symbol, order.side, order.quantity, order.price
                )
            except (LimitViolation, OrderRateExceeded) as exc:
                rejected.append(OrderAssessment(order, report, str(exc)))
                continue
            except ComplianceViolation as exc:  # pragma: no cover - defensive guard
                rejected.append(OrderAssessment(order, report, str(exc)))
                continue
            accepted.append(assessment)
            # Assume immediate fill to keep exposure tracking consistent for subsequent orders.
            self._risk.register_fill(
                order.symbol, order.side, order.quantity, order.price
            )
        return WorkflowAssessment(tuple(accepted), tuple(rejected))

    def evaluate_from_dicts(
        self, payloads: Iterable[dict[str, object]]
    ) -> WorkflowAssessment:
        """Helper accepting dictionaries (for fixtures and JSON payloads)."""

        orders: list[OrderRequest] = []
        for payload in payloads:
            symbol = str(payload.get("symbol"))
            side = str(payload.get("side", "buy")).lower()
            quantity = float(payload.get("quantity", 0.0))
            price = float(payload.get("price", 0.0))
            orders.append(
                OrderRequest(symbol=symbol, side=side, quantity=quantity, price=price)
            )
        return self.evaluate(orders)


__all__ = [
    "OrderRequest",
    "OrderAssessment",
    "WorkflowAssessment",
    "RiskComplianceWorkflow",
]