How can I validate a dataclass's fields without hiding construction errors?

For a dataclass using its generated initializer, put the check in __post_init__. Python calls that method after the generated __init__, so it is a natural place to check an invariant across fields and raise a specific exception if the combination is invalid. [S1]

For example, assume a booking record must have an end time later than its start time. The rule is illustrative; adapt it to your own fields:

from dataclasses import dataclass

@dataclass
class Booking:
    start: int
    end: int

    def __post_init__(self) -> None:
        if self.end <= self.start:
            raise ValueError("end must be greater than start")

The check sits with the definition of what makes a Booking valid. It does not require a separate caller to remember to invoke a validation function.

Raise the exception at the point where the rule is checked, and include the violated condition in its message. In the example, ValueError and “end must be greater than start” tell the caller what input needs attention.

Avoid wrapping construction in a broad try/except that discards the error or returns a fallback that looks successful. If a caller needs to handle invalid input, catch the expected exception at the boundary where it can decide what to do, and preserve or report the error. That keeps validation failure distinct from successful construction and unrelated errors.

Test one valid case and one invalid case. For the invalid case, assert the exception type and, if the wording is part of what you want to maintain, its message:

import unittest

class BookingTests(unittest.TestCase):
    def test_valid_time_range_can_be_created(self):
        booking = Booking(start=9, end=10)
        self.assertEqual(booking.start, 9)

    def test_end_must_be_after_start(self):
        with self.assertRaisesRegex(
            ValueError, "end must be greater than start"
        ):
            Booking(start=10, end=9)

This checks both sides of the invariant: acceptable input remains constructible, and the invalid combination raises the intended error. If exact message wording is not important to your project, use assertRaises(ValueError) instead of matching the text.

Check that the class uses the dataclass-generated __init__. The automatic __post_init__ call does not happen when the class has no generated __init__, such as when you provide your own initializer. [S1] If you define a custom initializer, decide explicitly where it will enforce the same rule; do not assume the generated behavior still applies.

A practical review checklist is: identify the invariant in plain language, put the check in __post_init__ for a generated initializer, raise a specific and informative exception, test one valid and one invalid construction, and confirm a custom initializer has not displaced the expected validation path. The documentation supports the generated-initializer behavior; it does not determine which invariant or exception type is right for your application.