Validation de l'entrée lors de la mutation d'une classe de données

Peut-être verrouiller l'attribut en utilisant getters et setters au lieu de muter l'attribut directement . Si vous extrayez ensuite votre logique de validation dans une méthode distincte, vous pouvez valider de la même manière à la fois à partir de votre setter et de la fonction __post_init__ .

Les classes de données sont un mécanisme permettant de fournir une initialisation par défaut pour accepter les attributs en tant que paramètres, et une belle représentation, ainsi que quelques subtilités comme le hook __post_init__ .

Heureusement, elles ne dérangent aucun autre mécanisme d'accès aux attributs en Python - et vous pouvez toujours créer vos attributs sans classe de données en tant que descripteurs de propriété , ou en tant que classe de descripteur personnalisée si vous le souhaitez. De cette façon, tout accès aux attributs passera automatiquement par vos fonctions getter et setter.

Le seul inconvénient de l'utilisation de la propriété intégrée par défaut est que vous devez l'utiliser dans «l'ancienne méthode», et non avec la syntaxe du décorateur - qui vous permet de créer des annotations pour vos attributs.

Ainsi, les «descripteurs» sont des objets spéciaux affectés aux attributs de classe en Python d'une manière que tout accès à cet attribut appellera les méthodes des descripteurs __get__ , __set__ ou __del__ . La propriété intégrée est un moyen de construire un descripteur passé 1 à 3 fonctions qui seront appelées à partir de ces méthodes.

Donc, sans descripteur personnalisé, vous pouvez faire:

def positive_validator(name, value):
    if value <= 0:
        raise ValueError(f"values for {name!r}  have to be positive")

class MyAttr:
     def __init__(self, type, validators=()):
          self.type = type
          self.validators = validators

     def __set_name__(self, owner, name):
          self.name = name

     def __get__(self, instance, owner):
          if not instance: return self
          return instance.__dict__[self.name]

     def __delete__(self, instance):
          del instance.__dict__[self.name]

     def __set__(self, instance, value):
          if not isinstance(value, self.type):
                raise TypeError(f"{self.name!r} values must be of type {self.type!r}")
          for validator in self.validators:
               validator(self.name, value)
          instance.__dict__[self.name] = value

#And now

@dataclass
class Person:
    name: str = MyAttr(str)
    age: float = MyAttr((int, float), [positive_validator,])

En utilisant cette approche, vous devrez écrire l'accès de chaque attribut comme deux méthodes / fonctions, mais vous n'aurez plus besoin d'écrire votre code __post_init __ >: chaque attribut se validera.

Notez également que cet exemple a pris la petite approche habituelle de stockage des attributs normalement dans le __dict__ de l'instance. Dans les exemples sur le Web, la pratique consiste à utiliser un accès aux attributs normal, mais en ajoutant au nom un _ . Cela laissera ces attributs polluer un dir sur votre instance finale, et les attributs privés ne seront pas protégés.

Une autre approche consiste à écrire votre propre classe de descripteur et à la laisser vérifier l'instance et les autres propriétés des attributs que vous souhaitez protéger. Cela peut être aussi sophistiqué que vous le souhaitez, aboutissant à votre propre cadre. Donc, pour une classe de descripteur qui vérifiera le type d'attribut et acceptera une liste de validateurs, vous aurez besoin de:

@dataclass
class MyClass:
   def setname(self, value):
       if not isinstance(value, str):
           raise TypeError(...)
       self.__dict__["name"] = value
   def getname(self):
       return self.__dict__.get("name")
   name: str = property(getname, setname)
   # optionally, you can delete the getter and setter from the class body:
   del setname, getname

Voilà - la création de votre propre classe de descripteur nécessite un peu plus connaissances sur Python, mais le code donné ci-dessus devrait être bon pour une utilisation, même en production - vous êtes invités à l'utiliser.

Notez que vous pouvez facilement ajouter beaucoup d'autres vérifications et transformations pour chacun de vos attributs - et le code dans __set_name__ lui-même pourrait être modifié pour introspecter les __annotations__ dans la classe owner pour prendre automatiquement note des types - afin que le type ne serait pas nécessaire pour la classe MyAttr elle-même. Mais comme je l'ai déjà dit: vous pouvez le rendre aussi sophistiqué que vous le souhaitez.

Une solution simple et flexible peut être de remplacer la méthode __setattr__ :

@dataclass
class Person:
    name: str
    age: float

    def __setattr__(self, name, value):
        if name == 'age':
            assert value > 0, f"value of {name} can't be negative: {value}"
        self.__dict__[name] = value