Python类型检查系统

Question

我正在尝试用 Python 创建自定义类型系统。以下是代码。

from inspect import Signature, Parameter

class Descriptor():
    def __init__(self, name=None):
        self.name = name

    def __set__(self, instance, value):
        instance.__dict__[self.name] = value

    def __get__(self, instance, cls):
        return instance.__dict__[self.name]

class Typed(Descriptor):
    ty = object
    def __set__(self, instance, value):
        if not isinstance(value, self.ty):
            raise TypeError('Expected %s' %self.ty)
        super().__set__(instance, value)

class Integer(Typed):
    ty = int

class Float(Typed):
    ty = float

class String(Typed):
    ty = str

class Positive(Descriptor):
    def __set__(self, instance, value):
        if value < 0:
            raise ValueError('Expected >= 0')
        super().__set__(instance, value)

class PosInteger(Integer, Positive):
    pass

class Sized(Descriptor):
    def __init__(self, *args, maxlen, **kwargs):
        self.maxlen = maxlen
        super().__init__(*args, **kwargs)

    def __set__(self, instance, value):
        if len(value) > self.maxlen:
            raise ValueError('TooBig')
        super().__set__(instance, value)

class SizedString(String, Sized):
    pass

def make_signature(names):
    return Signature([Parameter(name, Parameter.POSITIONAL_OR_KEYWORD) for name in names])

class StructMeta(type):

    def __new__(cls, name, bases, clsdict):
        fields = [key for key, value in clsdict.items() if isinstance(value, Descriptor)]

        for name in fields:
            #print(type(clsdict[name]))
            clsdict[name].name = name

        clsobj = super().__new__(cls, name, bases, clsdict)
        sig = make_signature(fields)
        setattr(clsobj, '__signature__', sig)
        return clsobj

class Structure(metaclass = StructMeta):
    def __init__(self, *args, **kwargs):
        bound = self.__signature__.bind(*args, **kwargs)
        for name, value in bound.arguments.items():
            setattr(self, name, value)

使用上述类型系统，我摆脱了所有必须在类中(主要在 init 内部)编写的样板代码和重复代码，以检查类型、验证值等。

通过使用上面的代码，我的类看起来就像这样简单

class Stock(Structure):
        name =  SizedString(maxlen=9)
        shares =  PosInteger()
        price = Float()

 stock = Stock('AMZN', 100, 1600.0)

到这里一切都正常。现在我想扩展此类型检查功能并创建包含其他类的对象的类。例如，价格现在不再是 Float，而是 Price 类型(即另一类 Price)。

class Price(Structure):
    currency = SizedString(maxlen=3)
    value = Float() 

class Stock(Structure):
    name =  SizedString(maxlen=9)
    shares =  PosInteger()
    price = Price() # This won't work. 

这不起作用，因为“price = Price()”行将调用 Price 的构造函数，并期望将货币和值传递给构造函数，因为 Price 是结构而不是描述符。它抛出“TypeError:缺少必需的参数:‘货币’”。

但我希望它能够工作并使其看起来像上面那样，因为归根结底，Price 也是一种类似于 PosInteger 的类型，但同时它也必须是 Structure。即 Price 应该继承自 Structure，但同时它也必须是一个描述符。

我可以通过定义另一个类(例如“PriceType”)来使其工作

class Price(Structure):
    currency = SizedString(maxlen=3)
    value = Float()

class PriceType(Typed):
    ty = Price

class Stock(Structure):
    name =  SizedString(maxlen=9)
    shares =  PosInteger()
    price = PriceType()

stock = Stock('AMZN', 100, Price('INR', 2400.0))

但这看起来有点奇怪 - Price 和 PriceType 作为两个不同的类。有人可以帮助我了解是否可以避免创建 PriceType 类吗？

我还失去了为字段提供默认值的功能。

例如，如何将股票中股票字段的默认值保留为 0 或将价格中货币字段的默认值保留为“美元”？即如下所示。

class Stock:
    def __init__(name, price, shares=0)

class Price
    def __init__(value, currency = 'USD')

Answer 1

一个快速的做法是使用一个简单的函数，在声明字段时构建“PriceType”(和等效项)。

由于不需要描述符类本身的唯一性，并且创建类所需的相对较长时间也不是问题，因为主体类中的字段仅在程序加载时创建，因此您应该可以使用:

def typefield(cls, *args, extra_checkers = (), **kwargs):
    descriptor_class = type(
        cls.__name__,
        (Typed,) + extra_checkers,
        {'ty': cls}
    )
    return descriptor_class(*args, **kwargs)

现在，这样的代码应该可以正常工作:

class Stock(Structure):
    name =  SizedString(maxlen=9)
    shares =  PosInteger()
    price = typefield(Price, "price")

(另请注意，Python 3.6+ 将 __set_name__ 方法合并到 descriptor protocol 中 - 如果使用此方法，则无需将字段名称作为参数传递给默认值描述符 __init__，并输入字段名称两次)

更新

在您的评论中，您似乎暗示希望您的 Structure 类将自身用作描述符 - 这不会很好地工作 - 描述符 __get__ 和 __set__ 方法是类方法 - 您希望用结构的实际实例填充字段。

可以做的就是将上面的 typefield 方法移动到 Structure 中的类方法中，让它注释您想要的默认参数，并为这些类型的字段创建一个新的中间描述符类读取时会自动创建一个具有默认值的实例。此外，ty 可以只是描述符中的实例属性，因此无需为字段创建动态类:

class StructField(Typed):
    def __init__(self, *args, ty=None, def_args=(), def_kw=None, **kw):
        self.def_args = def_args
        self.def_kw = def_kw or {}
        self.ty = ty
        super().__init__(*args, **kw)
    def __get__(self, instance, owner):
         if self.name not in instance.__dict__:
              instance.__dict__[self.name] = self.ty(*self.def_args, **self.def_kw)
         return super().__get__(instance, owner)


    ...

    class Structure(metaclass=StructMeta):
        ...
        @classmethod
        def field(cls, *args, **kw):  
         # Change the signature if you want extra parameters 
         # for the field, like extra validators, and such
            return StructField(ty=cls, def_args=args, def_kw=kw)

...

class Stock(Structure):
    ...
    price = Price.field("USD", 20.00)