Hey there! Totally get where you're coming from—dataclasses can feel a bit fuzzy when you're wrapping your head around private attributes, __post_init__, and accessor patterns, especially when trying to map different use cases to the right implementation. Let's break down your questions one by one, using the code structure you learned as a foundation.

1. How does scenario 3 work? (Mutable but read-only attributes) #

You’re exactly right: for read-only mutable attributes (where the dataclass itself isn’t frozen, but you don’t want external code modifying the attribute after initialization), you do validate invariants in __post_init__ just like in scenario 2.

Since you won’t provide a setter method, the class constructor (and by extension __post_init__) is the only entry point for setting the attribute. This means you need to enforce your invariant here to ensure the value is valid from the start. Here’s a concrete example:

from dataclasses import dataclass, InitVar, field

@dataclass
class ReadOnlyValidatedExample:
    '''Invariant: attr must be positive, and read-only after init'''
    attr: InitVar[int]
    __attr: int = field(init=False)

    def __post_init__(self, attr: int) -> None:
        # Validate once during initialization (only way to set the value)
        assert attr > 0, "Attribute must be positive"
        self.__attr = attr

    def get_attr(self) -> int:
        return self.__attr
        # No set_attr method = external code can't modify __attr

If there’s no invariant for the read-only attribute, you can skip the assert and just assign the value directly in __post_init__.

2. What to do when there’s no invariant? #

If your attribute has no rules (e.g., it can be any integer, string, etc.), your implementation depends on whether you want to encapsulate the attribute or not:

Case A: Encapsulated, read-write attribute

You can still use the InitVar + getter/setter pattern, but simplify the logic to remove validation:

@dataclass
class NoInvariantReadWrite:
    attr: InitVar[int]
    __attr: int = field(init=False)

    def __post_init__(self, attr: int) -> None:
        self.set_attr(attr)  # No validation needed here

    def get_attr(self) -> int:
        return self.__attr

    def set_attr(self, attr: int) -> None:
        self.__attr = attr  # Simple assignment, no assert

Case B: Encapsulated, read-only attribute

Skip validation (since there’s no invariant) and just assign the value in __post_init__, then only provide a getter:

@dataclass
class NoInvariantReadOnly:
    attr: InitVar[int]
    __attr: int = field(init=False)

    def __post_init__(self, attr: int) -> None:
        self.__attr = attr

    def get_attr(self) -> int:
        return self.__attr

Case C: No encapsulation (simplest option)

If you don’t need to hide the attribute behind getters/setters at all, you can use dataclasses’ default behavior and skip InitVar + __post_init__ entirely:

@dataclass
class SimplePublicAttribute:
    attr: int  # External code can read/write directly, no validation

3. Are there any other basic cases I missed? #

You covered the core scenarios, but here are a few common basic cases that might fill in the gaps:

Scenario 4: Derived/computed attributes

If an attribute is calculated from other input attributes (not passed directly to the constructor), you don’t need a setter. You can either compute it once in __post_init__ or calculate it dynamically in the getter:

@dataclass
class DerivedAttributeExample:
    width: InitVar[int]
    height: InitVar[int]
    __area: int = field(init=False)

    def __post_init__(self, width: int, height: int) -> None:
        # Validate inputs first, then compute the derived value
        assert width > 0 and height > 0, "Dimensions must be positive"
        self.__area = width * height

    def get_area(self) -> int:
        return self.__area

Or for dynamic calculations (if the source attributes are mutable):

@dataclass
class DynamicDerivedExample:
    width: int
    height: int

    def get_area(self) -> int:
        return self.width * self.height  # Recalculates every time it's called

Scenario 5: Joint invariants across multiple attributes

If your invariant depends on multiple attributes (e.g., a < b), you need to validate all related attributes both in __post_init__ and in any setters that modify them:

@dataclass
class JointInvariantExample:
    a: InitVar[int]
    b: InitVar[int]
    __a: int = field(init=False)
    __b: int = field(init=False)

    def __post_init__(self, a: int, b: int) -> None:
        self.set_a_and_b(a, b)

    def get_a(self) -> int:
        return self.__a

    def get_b(self) -> int:
        return self.__b

    def set_a_and_b(self, a: int, b: int) -> None:
        assert a < b, "a must be less than b"
        self.__a = a
        self.__b = b

    # If allowing single-attribute updates, re-validate the joint invariant
    def set_a(self, a: int) -> None:
        assert a < self.__b, "a must be less than b"
        self.__a = a

Scenario 6: Attributes with default values + invariants

If an attribute has a default value, you still need to ensure it meets your invariant. The easiest way is to call your setter in __post_init__, which will validate both user-provided values and the default:

@dataclass
class DefaultValueValidatedExample:
    attr: InitVar[int] = 10  # Default value
    __attr: int = field(init=False)

    def __post_init__(self, attr: int) -> None:
        self.set_attr(attr)  # Validates the default value too

    def get_attr(self) -> int:
        return self.__attr

    def set_attr(self, attr: int) -> None:
        assert attr > 0, "Attribute must be positive"
        self.__attr = attr

Quick Cheat Sheet of Basic Scenarios #

To wrap up, here’s a concise list of all the basic cases you might encounter:

1. Mutable attribute with invariant: InitVar + __post_init__ + getter + setter (your original example)
2. Frozen (immutable) attribute with invariant: InitVar + __post_init__ validation + getter only
3. Read-only mutable attribute (with/without invariant): InitVar + __post_init__ (validation if needed) + getter only
4. Derived/computed attribute: No setter; compute in __post_init__ or dynamic getter
5. Joint invariants across attributes: Validate in __post_init__ and all relevant setters
6. No invariant (simple attribute): Public attribute (simplest) or encapsulated with no validation

Don’t worry if this feels overwhelming at first—these patterns become second nature once you write a few examples. Your questions are totally valid, and it’s great that you’re digging into the details to build confidence. Good luck with your course! 😊