design patterns: the best way to introduce a restriction in the values ​​of a dictionary?

Let's say we have a Person class:

class Person:
    def __init__(self):
        self.moods = {
            "happy": 5,
            "angry": 5,
            "sad": 5
        }

    def updateStates(self, stateUpdates: {}):
        for mood, valChange in stateUpdates.items():
            self.moods(mood) += valChange

How could a restriction on the values ​​of self.moods?

I tried to implement it using descriptors, although I don't like it.

The following works but I don't think it's worth it because now I have to add .__get__(instance=self, owner=None) to self.moods() every time I need to access a mood, or .__set__(instance=self, value=) When you want to update one. This will quickly contaminate my code and make it illegible, so I am not a fan of this approach.

class OneDigitNumericValue():    # descriptor class
    def __set_name__(self, owner, name):
        self.name = name

    def __init__(self, defaultVal=5):
        self.value = defaultVal

    def __get__(self, instance, owner) -> object:
        return self.value

    def __set__(self, instance, value) -> None:
        if not (0 < value < 9) or int(value) != int:
            raise AttributeError("The value is invalid")
        self.value = value

class Person:
    moods = {
        "happy": OneDigitNumericValue(),
        "angry": OneDigitNumericValue(),
        "sad": OneDigitNumericValue()
    }

    def updateStates(self, stateUpdates: {}):
        for mood, valChange in stateUpdates.items():
            oldVal = self.moods(mood).__get__(self, owner=None)
            self.moods(mood).__set__(self, value=oldVal + valChange)

So the question is: What would be a better way to implement restrictions on the values ​​of self.moods?