Builtin Exception Hierarchy

BaseException
 ├── BaseExceptionGroup                       (3.11)
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ExceptionGroup [BaseExceptionGroup]  (3.11)
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── BrokenPipeError
      │    │    ├── ConnectionAbortedError
      │    │    ├── ConnectionRefusedError
      │    │    └── ConnectionResetError
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    ├── PythonFinalizationError        (3.13)
      │    └── RecursionError
      ├── StopAsyncIteration
      ├── StopIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── BytesWarning
           ├── DeprecationWarning
           ├── EncodingWarning                (3.10)
           ├── FutureWarning
           ├── ImportWarning
           ├── PendingDeprecationWarning
           ├── ResourceWarning
           ├── RuntimeWarning
           ├── SyntaxWarning
           ├── UnicodeWarning
           └── UserWarning

def tree(cls: type, indent: int = 0) -> None:
    print(" " * indent + cls.__name__)
    for sub in sorted(cls.__subclasses__(), key=lambda c: c.__name__):
        if sub.__module__ == "builtins":
            tree(sub, indent + 2)


tree(BaseException)

def run_training(model, loader, ckpt_path: str) -> None:
    try:
        train(model, loader)
    except BaseException:
        save_checkpoint(model, ckpt_path)  # also on Ctrl+C: resume later
        raise

try:
    price = PRICES[model_name]
except KeyError:
    raise ConfigurationError(f"no price configured for model {model_name!r}") from None

import errno
import os

try:
    os.makedirs(cache_dir)
except FileExistsError:
    pass  # fine: the cache already exists (better: os.makedirs(cache_dir, exist_ok=True))
except OSError as err:
    if err.errno == errno.ENOSPC:
        raise ResourceExhaustedError("disk full while writing embedding cache", device=cache_dir) from err
    raise

import warnings


def retrieve(query: str, top_k: int = 5):
    if top_k > 100:
        warnings.warn(f"top_k={top_k} is slow and rarely improves answers", RuntimeWarning, stacklevel=2)
    ...

class InputValidationError(RagkitError, ValueError):
    """Bad caller input; also a ValueError for generic callers."""

import inspect
import openai

for name, cls in inspect.getmembers(openai, inspect.isclass):
    if issubclass(cls, BaseException):
        print(f"{name:35} {' -> '.join(c.__name__ for c in cls.__mro__[1:-2])}")

import traceback


def describe(err: BaseException) -> dict:
    """Serialise an exception chain for an error-tracking payload."""
    chain = []
    cur = err
    while cur is not None:
        chain.append({"type": type(cur).__qualname__, "message": str(cur),
                      "notes": list(getattr(cur, "__notes__", []))})
        cur = cur.__cause__ or (None if cur.__suppress_context__ else cur.__context__)
    return {"chain": chain, "traceback": "".join(traceback.format_exception(err))}

last_error = None
for attempt in range(3):
    try:
        return call()
    except TimeoutError as err:
        last_error = err
raise ProviderTimeoutError("3 attempts timed out") from last_error