Python 棉花糖父模式-如何在子模式之间共享验证装饰器？

我有一个父棉花糖模式“ParentSchema”和两个嵌套的子模式“ChildSchema1”和“ChildSchema2”。这两个嵌套的子模式都利用装饰器从棉花糖中进行字段验证。它们看起来像这样：

ParenSchema.py

from marshmallow import Schema, fields
from schemas.childSchema1 import ChildSchema1
from schemas.childSchema2 import ChildSchema2

    class ParentSchema(Schema):
        child1 = fields.Nested(ChildSchema1)
        child2 = fields.Nested(ChildSchema2)
        foo = fields.String()
        bar = fields.String()

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema2(Schema):
    common_field = fields.String()
    field3 = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Exact Same Validation logic as common_field from ChildSchema1
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema
from validators import *

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String(validate=validate_common_field)

ChildSchema1.py

from marshmallow import Schema, fields
from schemas.childSchema1 import ChildSchema1
from schemas.childSchema2 import ChildSchema2

    class ParentSchema(Schema):
        child1 = fields.Nested(ChildSchema1)
        child2 = fields.Nested(ChildSchema2)
        foo = fields.String()
        bar = fields.String()

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema2(Schema):
    common_field = fields.String()
    field3 = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Exact Same Validation logic as common_field from ChildSchema1
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema
from validators import *

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String(validate=validate_common_field)

ChildSchema2.py

from marshmallow import Schema, fields
from schemas.childSchema1 import ChildSchema1
from schemas.childSchema2 import ChildSchema2

    class ParentSchema(Schema):
        child1 = fields.Nested(ChildSchema1)
        child2 = fields.Nested(ChildSchema2)
        foo = fields.String()
        bar = fields.String()

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema2(Schema):
    common_field = fields.String()
    field3 = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Exact Same Validation logic as common_field from ChildSchema1
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema
from validators import *

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String(validate=validate_common_field)

---

鉴于ChildSchema1和ChildSchema2都有一个同名字段，具有相同的验证器函数，我很乐意遵循并将该函数拉到ParentSchema.py。

我发现的一个解决方案是创建一个单独的类来承载共享验证函数：

def validate_common_field(self, common_field):
    try:
        # Exact Same Validation logic as common_field from ChildSchema1
    except:
        raise ValidationError('common_field is not valid')

通过移除@validates装饰符并在schema字段中使用

validate

参数，使用ChildSchema1和ChildSchema2中的值

ChildSchema1.py

from marshmallow import Schema, fields
from schemas.childSchema1 import ChildSchema1
from schemas.childSchema2 import ChildSchema2

    class ParentSchema(Schema):
        child1 = fields.Nested(ChildSchema1)
        child2 = fields.Nested(ChildSchema2)
        foo = fields.String()
        bar = fields.String()

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema2(Schema):
    common_field = fields.String()
    field3 = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Exact Same Validation logic as common_field from ChildSchema1
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema
from validators import *

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String(validate=validate_common_field)

验证器.py 从棉花糖导入验证错误，验证

def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

---

我发现的一个解决方案是创建一个单独的类来承载共享验证函数：

def validate_common_field(self, common_field):
    try:
        # Exact Same Validation logic as common_field from ChildSchema1
    except:
        raise ValidationError('common_field is not valid')

通过移除@validates装饰符并在schema字段中使用

validate

参数，使用ChildSchema1和ChildSchema2中的值

ChildSchema1.py

from marshmallow import Schema, fields
from schemas.childSchema1 import ChildSchema1
from schemas.childSchema2 import ChildSchema2

    class ParentSchema(Schema):
        child1 = fields.Nested(ChildSchema1)
        child2 = fields.Nested(ChildSchema2)
        foo = fields.String()
        bar = fields.String()

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema

class ChildSchema2(Schema):
    common_field = fields.String()
    field3 = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Exact Same Validation logic as common_field from ChildSchema1
        except:
            raise ValidationError('common_field is not valid')

from marshmallow import Schema, pprint, post_load
from marshmallow import fields, ValidationError, validates, validates_schema
from validators import *

class ChildSchema1(Schema):
    field1 = fields.String()
    field2 = fields.String()
    common_field = fields.String(validate=validate_common_field)

验证器.py 从棉花糖导入验证错误，验证

def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

---

您使用单独函数的方法很好

如果公共字段由两个子项共享，那么还可以使用继承来反映这一点，并分解字段和逻辑

class ChildSchema(Schema):
    common_field = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

class ChildSchema1(ChildSchema):
    field1 = fields.String()
    field2 = fields.String()

class ChildSchema2(ChildSchema):
    field3 = fields.String()

---

您使用单独函数的方法很好

如果公共字段由两个子项共享，那么还可以使用继承来反映这一点，并分解字段和逻辑

class ChildSchema(Schema):
    common_field = fields.String()

    @validates("common_field")
    def validate_common_field(self, common_field):
        try:
            # Validation logic
        except:
            raise ValidationError('common_field is not valid')

class ChildSchema1(ChildSchema):
    field1 = fields.String()
    field2 = fields.String()

class ChildSchema2(ChildSchema):
    field3 = fields.String()