【Python】例外クラス自作入門：エラー原因を明確にする設計術

# 最小限のカスタム例外クラスの例

class MyAppError(Exception):
    """アプリ共通の基底例外クラス"""
    pass


def do_something():
    # 何らかのアプリ固有のエラーが起きたと仮定
    raise MyAppError("アプリで処理できない状態が発生しました")


if __name__ == "__main__":
    try:
        do_something()
    except MyAppError as e:
        # カスタム例外として捕捉できる
        print(f"カスタム例外を捕捉しました: {e}")

class ValidationError(Exception):
    """入力値バリデーションで発生する例外"""

    def __init__(self, message: str, *, code: str | None = None, field: str | None = None):
        # 親クラス(Exception)のコンストラクタにもメッセージを渡す
        super().__init__(message)
        # 独自の属性を追加
        self.code = code
        self.field = field


def register_user(name: str):
    if not name:
        # フィールド名とエラーコードを付与して例外を投げる
        raise ValidationError(
            "ユーザー名は必須です",
            code="REQUIRED",
            field="name",
        )
    print(f"ユーザー登録成功: {name}")


if __name__ == "__main__":
    try:
        register_user("")
    except ValidationError as e:
        # ログ出力などで属性を活用できる
        print(f"[ValidationError] message={e}, code={e.code}, field={e.field}")

class MyAppError(Exception):
    """アプリケーション共通の基底例外"""
    pass


class DomainError(MyAppError):
    """ドメインロジック関連の例外"""
    pass


class InfrastructureError(MyAppError):
    """外部システム・インフラ関連の例外"""
    pass


class UserNotFoundError(DomainError):
    """ユーザーが存在しない場合の例外"""
    pass


class PaymentAPIError(InfrastructureError):
    """決済APIとの通信で発生する例外"""
    pass


def get_user(user_id: int):
    raise UserNotFoundError(f"ユーザーが見つかりません: user_id={user_id}")


def charge_payment(user_id: int, amount: int):
    raise PaymentAPIError(f"決済APIエラーが発生しました: user_id={user_id}, amount={amount}")


if __name__ == "__main__":
    try:
        get_user(1)
    except DomainError as e:
        print(f"[DomainError] {e}")

    try:
        charge_payment(1, 1000)
    except InfrastructureError as e:
        print(f"[InfrastructureError] {e}")

class FieldError:
    """単一フィールドのバリデーションエラー情報を保持するクラス"""

    def __init__(self, field: str, message: str, code: str | None = None):
        self.field = field
        self.message = message
        self.code = code

    def __repr__(self) -> str:
        return f"FieldError(field={self.field!r}, message={self.message!r}, code={self.code!r})"


class ValidationError(Exception):
    """複数フィールドのバリデーションエラーをまとめて扱う例外"""

    def __init__(self, errors: list[FieldError]):
        messages = ", ".join(f"{e.field}: {e.message}" for e in errors)
        super().__init__(messages)
        self.errors = errors


def validate_user_input(name: str, age: int) -> None:
    errors: list[FieldError] = []

    if not name:
        errors.append(FieldError("name", "名前は必須です", code="REQUIRED"))
    if age < 0:
        errors.append(FieldError("age", "年齢は0以上である必要があります", code="MIN_VALUE"))
    if errors:
        raise ValidationError(errors)


if __name__ == "__main__":
    try:
        validate_user_input("", -5)
    except ValidationError as e:
        print("バリデーションエラーが発生しました")
        for err in e.errors:
            print(f"  - field={err.field}, message={err.message}, code={err.code}")

import requests


class APIError(Exception):
    """外部API通信に関する基底例外"""
    pass


class APITimeoutError(APIError):
    """APIのタイムアウト"""
    pass


class APIResponseError(APIError):
    """APIレスポンスが不正、または期待しないステータスコード"""
    def __init__(self, status_code: int, message: str | None = None):
        self.status_code = status_code
        super().__init__(message or f"Unexpected status code: {status_code}")


def fetch_user_profile(user_id: int) -> dict:
    url = f"https://api.example.com/users/{user_id}"
    try:
        res = requests.get(url, timeout=1.0)
    except requests.Timeout as e:
        # ライブラリ例外をアプリ固有の例外に変換
        raise APITimeoutError(f"ユーザープロファイル取得でタイムアウトしました: user_id={user_id}") from e
    except requests.RequestException as e:
        raise APIError(f"ユーザープロファイル取得で通信エラーが発生しました: {e}") from e

    if res.status_code != 200:
        raise APIResponseError(res.status_code, f"ユーザー取得に失敗しました: status_code={res.status_code}")

    return res.json()

class PaymentAPIError(Exception):
    def __init__(self, user_id: int, amount: int, reason: str):
        message = (
            f"決済API呼び出しに失敗しました "
            f"(user_id={user_id}, amount={amount}, reason={reason})"
        )
        super().__init__(message)
        self.user_id = user_id
        self.amount = amount
        self.reason = reason


def charge(user_id: int, amount: int):
    # 処理の都合で意図的にエラーを発生させてみる
    raise PaymentAPIError(user_id, amount, reason="timeout")


if __name__ == "__main__":
    try:
        charge(123, 1000)
    except PaymentAPIError as e:
        # ログにそのまま出しても状況が把握しやすい
        print(f"[ERROR] {e}")
        # 属性をJSONに整形して構造化ログにすることも可能
        print(
            {
                "error": "PaymentAPIError",
                "user_id": e.user_id,
                "amount": e.amount,
                "reason": e.reason,
            }
        )

class MyAppError(Exception):
    pass


class ValidationError(MyAppError):
    pass


class APIError(MyAppError):
    pass


def use_case(user_input: dict) -> dict:
    if "name" not in user_input:
        raise ValidationError("nameは必須です")
    if user_input.get("name") == "api_error":
        raise APIError("外部APIエラー")
    return {"message": "ok"}


def handle_request(user_input: dict) -> tuple[int, dict]:
    try:
        result = use_case(user_input)
        return 200, result
    except ValidationError as e:
        # クライアントの入力ミスとして400を返す
        return 400, {"error": "validation_error", "message": str(e)}
    except APIError as e:
        # 一時的な障害として503を返す
        return 503, {"error": "api_error", "message": str(e)}
    except MyAppError as e:
        # 想定内だが分類されていないアプリエラー
        return 500, {"error": "app_error", "message": str(e)}
    except Exception as e:
        # 想定外のバグなど
        return 500, {"error": "unexpected_error", "message": "予期しないエラーが発生しました"}


if __name__ == "__main__":
    print(handle_request({"name": "alice"}))
    print(handle_request({}))  # ValidationError
    print(handle_request({"name": "api_error"}))  # APIError

# mylib/exceptions.py

class MyLibError(Exception):
    """ライブラリ共通の基底例外"""
    pass


class ConfigError(MyLibError):
    """設定ファイルの不備など"""
    pass


class ConnectionError(MyLibError):
    """接続に関連するエラー"""
    pass


class DataFormatError(MyLibError):
    """データフォーマットが不正な場合"""
    pass

# mylib/client.py

from .exceptions import (
    MyLibError,
    ConfigError,
    ConnectionError,
    DataFormatError,
)


def load_config(path: str) -> dict:
    if not path.endswith(".yaml"):
        raise ConfigError("設定ファイルは.yaml形式である必要があります")
    # 実装は省略
    return {}


def fetch_data() -> dict:
    # 実装は省略し、例としてエラーを発生
    raise ConnectionError("サーバーに接続できませんでした")


def parse_data(raw: str) -> dict:
    # 実装は省略し、例としてエラーを発生
    raise DataFormatError("JSONとして解析できませんでした")

# ライブラリ利用者側のコード例

from mylib.client import load_config, fetch_data, parse_data
from mylib.exceptions import MyLibError, ConfigError, ConnectionError, DataFormatError


def main():
    try:
        config = load_config("settings.yaml")
        raw = fetch_data()
        data = parse_data(raw)
    except ConfigError as e:
        print(f"設定エラー: {e}")
    except ConnectionError as e:
        print(f"接続エラー: {e}")
    except DataFormatError as e:
        print(f"データ形式エラー: {e}")
    except MyLibError as e:
        print(f"ライブラリ内のその他のエラー: {e}")


if __name__ == "__main__":
    main()