Python如何使用描述符写属性验证框架

import logging
logging.basicConfig(level=logging.INFO)
class LoggedAgeAccess:
    def __get__(self, obj, objtype=None):
        value = obj._age
        logging.info('Accessing %r giving %r', 'age', value)
        return value
    def __set__(self, obj, value):
        logging.info('Updating %r to %r', 'age', value)
        obj._age = value
class Person:
    age = LoggedAgeAccess()   # 关键：描述符作为类变量
    def __init__(self, name, age):
        self.name = name        # 普通属性：不走描述符
        self.age = age          # 触发 __set__()！
    def birthday(self):
        self.age += 1           # 触发 __get__() 和 __set__()

class Person:
    name = LoggedAccess()    # 类定义时，Python 自动调用 __set_name__(Person, 'name')
    age = LoggedAccess()     # 类定义时，Python 自动调用 __set_name__(Person, 'age')

class LoggedAccess:
    def __set_name__(self, owner, name):
        self.public_name = name           # 'name'
        self.private_name = '_' + name    # '_name'
    def __get__(self, obj, objtype=None):
        value = getattr(obj, self.private_name)
        logging.info('Accessing %r giving %r', self.public_name, value)
        return value
    def __set__(self, obj, value):
        logging.info('Updating %r to %r', self.public_name, value)
        setattr(obj, self.private_name, value)
class Person:
    name = LoggedAccess()    # 自动命名
    age = LoggedAccess()     # 自动命名
    def __init__(self, name, age):
        self.name = name
        self.age = age
pete = Person('Peter P', 10)
# 日志输出：
# INFO:root:Updating 'name' to 'Peter P'
# INFO:root:Updating 'age' to 10
print(vars(pete))  # {'_name': 'Peter P', '_age': 10}

class Product:
    def __init__(self, name, price, category):
        if not isinstance(name, str) or len(name) < 3:
            raise ValueError('name must be a string with at least 3 chars')
        if not isinstance(price, (int, float)) or price < 0:
            raise ValueError('price must be non-negative')
        if category not in ('electronics', 'clothing', 'food'):
            raise ValueError('invalid category')
        self.name = name
        self.price = price
        self.category = category

class Product:
    name = String(minsize=3, maxsize=50)
    price = Number(minvalue=0)
    category = OneOf('electronics', 'clothing', 'food')

from abc import ABC, abstractmethod
class Validator(ABC):
    """验证器抽象基类：同时作为数据描述符使用。"""
    def __set_name__(self, owner, name):
        self.private_name = '_' + name
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return getattr(obj, self.private_name)
    def __set__(self, obj, value):
        self.validate(value)           # 先验证
        setattr(obj, self.private_name, value)  # 再存储
    @abstractmethod
    def validate(self, value):
        pass

class OneOf(Validator):
    def __init__(self, *options):
        self.options = set(options)
    def validate(self, value):
        if value not in self.options:
            raise ValueError(
                f'Expected {value!r} to be one of {self.options!r}'
            )

class Number(Validator):
    def __init__(self, minvalue=None, maxvalue=None):
        self.minvalue = minvalue
        self.maxvalue = maxvalue
    def validate(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError(f'Expected {value!r} to be an int or float')
        if self.minvalue is not None and value < self.minvalue:
            raise ValueError(f'Expected {value!r} to be at least {self.minvalue!r}')
        if self.maxvalue is not None and value > self.maxvalue:
            raise ValueError(f'Expected {value!r} to be no more than {self.maxvalue!r}')

class String(Validator):
    def __init__(self, minsize=None, maxsize=None, predicate=None):
        self.minsize = minsize
        self.maxsize = maxsize
        self.predicate = predicate
    def validate(self, value):
        if not isinstance(value, str):
            raise TypeError(f'Expected {value!r} to be a str')
        if self.minsize is not None and len(value) < self.minsize:
            raise ValueError(f'Expected {value!r} to be no smaller than {self.minsize!r}')
        if self.maxsize is not None and len(value) > self.maxsize:
            raise ValueError(f'Expected {value!r} to be no bigger than {self.maxsize!r}')
        if self.predicate is not None and not self.predicate(value):
            raise ValueError(f'Expected {self.predicate} to be true for {value!r}')

class Component:
    name = String(minsize=3, maxsize=10, predicate=str.isupper)
    kind = OneOf('wood', 'metal', 'plastic')
    quantity = Number(minvalue=0)
    def __init__(self, name, kind, quantity):
        self.name = name
        self.kind = kind
        self.quantity = quantity

Component('Widget', 'metal', 5)
# ValueError: Expected <method 'isupper' of 'str' objects> to be true for 'Widget'
Component('WIDGET', 'metle', 5)
# ValueError: Expected 'metle' to be one of {'metal', 'plastic', 'wood'}
Component('WIDGET', 'metal', -5)
# ValueError: Expected -5 to be at least 0
Component('WIDGET', 'metal', 'V')
# TypeError: Expected 'V' to be an int or float
c = Component('WIDGET', 'metal', 5)
print(c.name, c.kind, c.quantity)   # WIDGET metal 5
print(vars(c))  # {'_name': 'WIDGET', '_kind': 'metal', '_quantity': 5}

c.quantity = 10     # 合法
c.quantity = -1     # ValueError: Expected -1 to be at least 0