exception.py

"""Base exception class for UiPath runtime errors with structured error information."""

from __future__ import annotations

import sys
import traceback
from typing import Any

from uipath.core.errors import UiPathFaultedTriggerError

from uipath.runtime.errors.codes import UiPathErrorCode
from uipath.runtime.errors.contract import UiPathErrorCategory, UiPathErrorContract


class UiPathBaseRuntimeError(Exception):
    """Base exception class for UiPath runtime errors with structured error information."""

    def __init__(
        self,
        code: str,
        title: str,
        detail: str,
        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
        status: int | None = None,
        prefix: str = "Python",
        include_traceback: bool = True,
    ):
        """Initialize the UiPathBaseRuntimeError with structured error information."""
        # Get the current traceback as a string
        if include_traceback:
            tb = traceback.format_exc()
            if (
                tb and tb.strip() != "NoneType: None"
            ):  # Ensure there's an actual traceback
                detail = f"{detail}\n\n{tb}"

        if status is None:
            status = self._extract_http_status()

        self.error_info = UiPathErrorContract(
            code=f"{prefix}.{code}",
            title=title,
            detail=detail,
            category=category,
            status=status,
        )
        super().__init__(detail)

    def _extract_http_status(self) -> int | None:
        """Extract HTTP status code from the exception chain if present."""
        exc_info = sys.exc_info()
        if not exc_info or len(exc_info) < 2 or exc_info[1] is None:
            return None

        exc: BaseException | None = exc_info[1]  # Current exception being handled
        while exc is not None:
            if hasattr(exc, "status_code"):
                return exc.status_code

            if hasattr(exc, "response") and hasattr(exc.response, "status_code"):
                return exc.response.status_code

            # Move to the next exception in the chain
            next_exc = getattr(exc, "__cause__", None) or getattr(
                exc, "__context__", None
            )

            # Ensure next_exc is a BaseException or None
            exc = (
                next_exc
                if isinstance(next_exc, BaseException) or next_exc is None
                else None
            )

        return None

    @property
    def as_dict(self) -> dict[str, Any]:
        """Get the error information as a dictionary."""
        return self.error_info.model_dump()


class UiPathRuntimeError(UiPathBaseRuntimeError):
    """Exception class for UiPath runtime errors."""

    def __init__(
        self,
        code: UiPathErrorCode,
        title: str,
        detail: str,
        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
        status: int | None = None,
        prefix: str = "Python",
        include_traceback: bool = True,
    ):
        """Initialize the UiPathRuntimeError with structured error information."""
        super().__init__(
            code=code.value,
            title=title,
            detail=detail,
            category=category,
            status=status,
            prefix=prefix,
            include_traceback=include_traceback,
        )

    @classmethod
    def from_resume_trigger_error(
        cls, exc: UiPathFaultedTriggerError
    ) -> UiPathRuntimeError:
        """Create UiPathRuntimeError from UiPathFaultedTriggerError."""
        return cls(
            code=UiPathErrorCode.RESUME_TRIGGER_ERROR,
            title="Resume trigger error",
            detail=exc.message,
            category=UiPathErrorCategory(exc.category),
        )