Error Messages — User-Friendly Errors, Localization, and Standards

# error_builder.py
from typing import Any, Dict, List, Optional

class ErrorBuilder:
    @staticmethod
    def friendly_message(field: str, code: str) -> str:
        messages = {
            "required": f"{field} is required. Please fill in this field.",
            "type_error": f"{field} has the wrong type. Check the expected format.",
            "min_length": f"{field} is too short. Make it longer.",
            "max_length": f"{field} is too long. Shorten the value.",
            "min_value": f"{field} is too low. Increase the value.",
            "max_value": f"{field} is too high. Decrease the value.",
            "email": f"{field} does not look like a valid email address.",
            "pattern": f"{field} has an invalid format. Check the requirements.",
            "unique": f"{field} is already taken. Choose a different value.",
            "password_mismatch": "Passwords do not match. Retype both carefully.",
        }
        return messages.get(code, f"{field} is invalid.")

    @staticmethod
    def build_error(field: str, code: str, detail: Optional[str] = None) -> Dict:
        return {
            "field": field,
            "code": code,
            "message": detail or ErrorBuilder.friendly_message(field, code),
        }

    @staticmethod
    def build_errors(errors: List[Dict]) -> Dict:
        return {
            "valid": len(errors) == 0,
            "count": len(errors),
            "errors": errors,
        }

vb = ErrorBuilder()
errors = [
    vb.build_error("email", "required"),
    vb.build_error("password", "min_length", "Password must be at least 8 characters"),
    vb.build_error("confirm_password", "password_mismatch"),
]

result = vb.build_errors(errors)
print(f"Valid: {result['valid']}")
print(f"Count: {result['count']}")
for err in result["errors"]:
    print(f"  [{err['code']}] {err['field']}: {err['message']}")

# rfc7807_errors.py
from typing import Any, Dict, List, Optional
from dataclasses import dataclass, field, asdict
from datetime import datetime, timezone

@dataclass
class ValidationProblem:
    type: str = "about:blank"
    title: str = "Validation Error"
    status: int = 422
    detail: str = "One or more fields failed validation"
    instance: Optional[str] = None
    errors: List[Dict] = field(default_factory=list)

    def to_dict(self) -> Dict:
        result = {
            "type": self.type,
            "title": self.title,
            "status": self.status,
            "detail": self.detail,
            "errors": self.errors,
            "timestamp": datetime.now(timezone.utc).isoformat(),
        }
        if self.instance:
            result["instance"] = self.instance
        return result

def build_rfc7807_response(errors: List[Dict], instance: Optional[str] = None) -> Dict:
    problem = ValidationProblem(
        type="https://api.example.com/errors/validation",
        title="Validation Failed",
        status=422,
        detail=f"The request contains {len(errors)} validation error(s)",
        instance=instance,
        errors=errors,
    )
    return problem.to_dict()

rfc_errors = [
    {"field": "email", "code": "format", "message": "Must be a valid email address"},
    {"field": "age", "code": "range", "message": "Age must be between 13 and 150"},
]

response = build_rfc7807_response(rfc_errors, "/api/users")
print(f"Status: {response['status']}")
print(f"Title: {response['title']}")
print(f"Detail: {response['detail']}")
print(f"Instance: {response['instance']}")
for err in response["errors"]:
    print(f"  {err['field']}: {err['message']}")

# localization.py
from typing import Dict, List, Optional

class LocalizationEngine:
    def __init__(self):
        self.messages: Dict[str, Dict[str, str]] = {}
        self.fallback_locale = "en"

    def load(self, locale: str, messages: Dict[str, str]):
        self.messages[locale] = messages

    def translate(self, code: str, locale: str = "en", **kwargs) -> str:
        locale_messages = self.messages.get(locale, self.messages.get(self.fallback_locale, {}))
        template = locale_messages.get(code, locale_messages.get("fallback", "Validation error"))
        try:
            return template.format(**kwargs)
        except KeyError:
            return template

    def localize_error(self, error: Dict, locale: str = "en") -> Dict:
        localized = dict(error)
        code = error.get("code", "unknown")
        field = error.get("field", "field")
        localized["message"] = self.translate(code, locale, field=field)
        return localized

engine = LocalizationEngine()

engine.load("en", {
    "required": "{field} is required",
    "min_length": "{field} must be at least {min} characters",
    "email": "{field} must be a valid email",
    "fallback": "Invalid value for {field}",
})

engine.load("es", {
    "required": "{field} es obligatorio",
    "min_length": "{field} debe tener al menos {min} caracteres",
    "email": "{field} debe ser un correo valido",
    "fallback": "Valor invalido para {field}",
})

engine.load("fr", {
    "required": "{field} est requis",
    "min_length": "{field} doit contenir au moins {min} caracteres",
    "email": "{field} doit etre un email valide",
    "fallback": "Valeur invalide pour {field}",
})

errors = [
    {"field": "email", "code": "required"},
    {"field": "password", "code": "min_length", "min": 8},
]

for locale in ["en", "es", "fr"]:
    print(f"\nLocale: {locale}")
    for err in errors:
        localized = engine.localize_error(err, locale)
        print(f"  {localized['field']}: {localized['message']}")

# field_mapping.py
from typing import Any, Dict, List, Optional

class FieldMapper:
    def __init__(self):
        self.mappings: Dict[str, str] = {}

    def map(self, internal: str, external: str):
        self.mappings[internal] = external

    def to_external(self, internal_field: str) -> str:
        return self.mappings.get(internal_field, internal_field)

    def remap_errors(self, errors: List[Dict]) -> List[Dict]:
        remapped = []
        for err in errors:
            new_err = dict(err)
            new_err["field"] = self.to_external(err.get("field", ""))
            remapped.append(new_err)
        return remapped

    @staticmethod
    def flatten_nested(data: Dict, prefix: str = "") -> List[Dict]:
        errors = []
        for key, value in data.items():
            field_name = f"{prefix}.{key}" if prefix else key
            if isinstance(value, dict):
                if "message" in value or "code" in value:
                    errors.append({"field": field_name, **value})
                else:
                    errors.extend(FieldMapper.flatten_nested(value, field_name))
            elif isinstance(value, list):
                for i, item in enumerate(value):
                    nested_field = f"{field_name}[{i}]"
                    if isinstance(item, dict):
                        errors.extend(FieldMapper.flatten_nested(item, nested_field))
                    else:
                        errors.append({"field": nested_field, "message": str(item)})
            else:
                errors.append({"field": field_name, "message": str(value)})
        return errors

mapper = FieldMapper()
mapper.map("user.email", "email_address")
mapper.map("user.pass", "password")

raw_errors = [
    {"field": "user.email", "code": "required"},
    {"field": "user.pass", "code": "min_length", "message": "Password too short"},
]

remapped = mapper.remap_errors(raw_errors)
for err in remapped:
    print(f"  {err['field']}: {err.get('message', err['code'])}")

nested = {
    "user": {
        "name": {"code": "required"},
        "address": {
            "street": {"code": "required"},
            "city": {"code": "required"},
        }
    }
}
flat = FieldMapper.flatten_nested(nested)
print("\nFlattened nested errors:")
for err in flat:
    print(f"  {err['field']}: {err['code']}")

# error_standards.py
from typing import Any, Dict, List, Optional

class ErrorResponseFormatter:
    @staticmethod
    def simple(errors: List[Dict]) -> Dict:
        return {
            "success": False,
            "error": {
                "message": "Validation failed",
                "details": errors,
            }
        }

    @staticmethod
    def flat(errors: List[Dict]) -> Dict:
        result = {"success": False, "errors": {}}
        for err in errors:
            field = err.get("field", "general")
            result["errors"][field] = err.get("message", str(err))
        return result

    @staticmethod
    def array(errors: List[Dict]) -> Dict:
        return {
            "success": False,
            "errors": [{"field": e.get("field"), "message": e.get("message")} for e in errors]
        }

    @staticmethod
    def graphql_format(errors: List[Dict]) -> List[Dict]:
        return [
            {
                "message": e.get("message", "Validation error"),
                "extensions": {
                    "code": e.get("code", "VALIDATION_ERROR"),
                    "field": e.get("field"),
                }
            }
            for e in errors
        ]

fmt = ErrorResponseFormatter()
sample_errors = [
    {"field": "email", "code": "required", "message": "Email is required"},
    {"field": "password", "code": "min_length", "message": "Minimum 8 characters"},
]

print("Simple format:")
print(f"  {fmt.simple(sample_errors)}")

print("Flat format:")
print(f"  {fmt.flat(sample_errors)}")

print("Array format:")
print(f"  {fmt.array(sample_errors)}")

print("GraphQL format:")
for err in fmt.graphql_format(sample_errors):
    print(f"  {err}")

# error_handler.py
from typing import Any, Dict, List, Optional

class ErrorHandler:
    def __init__(self):
        self.locales = {
            "en": {"required": "{field} is required", "email": "Invalid email"},
            "es": {"required": "{field} es obligatorio", "email": "Email invalido"},
        }
        self.field_map = {"user_email": "email", "user_pass": "password"}

    def translate(self, code: str, field: str, locale: str = "en") -> str:
        msgs = self.locales.get(locale, self.locales["en"])
        template = msgs.get(code, f"Invalid {field}")
        return template.format(field=field)

    def format_error(self, field: str, code: str, locale: str = "en") -> Dict:
        external = self.field_map.get(field, field)
        return {
            "field": external,
            "code": code,
            "message": self.translate(code, external, locale),
        }

    def handle(self, raw_errors: List[Dict], locale: str = "en") -> Dict:
        formatted = [self.format_error(e["field"], e["code"], locale) for e in raw_errors]
        return {"valid": False, "count": len(formatted), "errors": formatted}

handler = ErrorHandler()
raw = [{"field": "user_email", "code": "required"}, {"field": "user_pass", "code": "required"}]

print(handler.handle(raw, "en"))
print(handler.handle(raw, "es"))