python-flask-wtforms组件流程源码

from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import core
from wtforms.fields import html5
from wtforms.fields import simple
from wtforms import widgets
from wtforms import validators

app = Flask(__name__, template_folder=‘templates‘)
app.debug = True

#0 定义LogonForm类
class LoginForm(Form):
　　 #1 StringField类的实例化
    name = simple.StringField(
        label=‘用户名‘,
        validators=[
            validators.DataRequired(message=‘用户名不能为空.‘),
            validators.Length(min=6, max=18, message=‘用户名长度必须大于%(min)d且小于%(max)d‘)
        ],
        widget=widgets.TextInput(),
        render_kw={‘class‘: ‘form-control‘}
    )
 
    pwd = simple.PasswordField(
        label=‘密码‘,
        validators=[
            validators.DataRequired(message=‘密码不能为空.‘),
            validators.Length(min=8, message=‘用户名长度必须大于%(min)d‘),
            validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
                              message=‘密码至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符‘)
        ],
        widget=widgets.PasswordInput(),
        render_kw={‘class‘: ‘form-control‘}
    )

    class Meta:
        csrf = False

    def validate_pwd(self,*args,**kwargs):
        pass


@app.route(‘/login‘, methods=[‘GET‘, ‘POST‘])
def login():
    if request.method == ‘GET‘:
　　　　 #2.实例化一个LoginForm对象
        form = LoginForm()
        return render_template(‘login.html‘, form=form)
    else:
        form = LoginForm(formdata=request.form)
        if form.validate():
            print(‘用户提交数据通过格式验证，提交的值为：‘, form.data)
        else:
            print(form.errors)
        return render_template(‘login.html‘, form=form)

def test():
    form = LoginForm()


if __name__ == ‘__main__‘:
    app.run()

metaclass的另外一种方式：
    class MyType(type):
        def __init__(self,*args,**kwargs):
            print(‘xxxx‘)
            super(MyType,self).__init__(*args,**kwargs)

        def __call__(cls, *args, **kwargs):
            obj = cls.__new__(cls,*args, **kwargs)
            cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj)
            return obj

    def with_metaclass(base):
        return MyType("MyType",(base,),{})

    class Foo(with_metaclass(object)):
        def __init__(self,name):
            self.name = name

    #打印结果：  xxxx    xxxx

class Form(with_metaclass(FormMeta, BaseForm)):
    pass

def with_metaclass(meta, base=object):
    return meta("NewBase", (base,), {})
　　 # FormMeta("NewBase", (BaseForm,), {})    # 通过FormMeta创建了一个NewBase类，NewBase类继承了BaseForm类
　　 # 那你有没有疑问，为什么 FormMeta类可以创建类呢？  我们去FormMeta类看看

class FormMeta(type):
　　pass
#发现FormMeta继承了type类，所以刚才我们的疑问迎刃而解。

class FormMeta(type):
    def __init__(cls, name, bases, attrs):
        type.__init__(cls, name, bases, attrs)
        cls._unbound_fields = None
        cls._wtforms_meta = None

class StringField(Field):
    pass
#发现StringField类中没有，那我们就去基类中

class Field(object):
        def __new__(cls, *args, **kwargs):
　　　　　　　#判断不成立，走else
        　　if ‘_form‘ in kwargs and ‘_name‘ in kwargs:
            　　return super(Field, cls).__new__(cls)
        　　else:
　　　　　　　　　#返回一个UnboundField对象
            　　return UnboundField(cls, *args, **kwargs)

class UnboundField(object):
    _formfield = True
    creation_counter = 0
    def __init__(self, field_class, *args, **kwargs):
        UnboundField.creation_counter += 1
        self.field_class = field_class
        self.args = args
        self.kwargs = kwargs
        self.creation_counter = UnboundField.creation_counter    #这个数字，在后面会根据这个进行排序

class FormMeta(type):
    def __call__(cls, *args, **kwargs):
        if cls._unbound_fields is None:
            fields = []
            #获取LoginForm类中的所有字段
            for name in dir(cls):
                if not name.startswith(‘_‘):
                    #获取该字段的值
                    unbound_field = getattr(cls, name)  #unbound_field 是一个UnboundField对象
                    if hasattr(unbound_field, ‘_formfield‘):         #    _formfield = True
                        fields.append((name, unbound_field))         # [("name",UnboundField对象),("pwd",UnboundField对象)]
            fields.sort(key=lambda x: (x[1].creation_counter, x[0]))  #根据UnboundField对象的creation_counter属性对fields列表进行排序
            cls._unbound_fields = fields                             # LoginForm._unbound_fields = [("name",UnboundField对象),("pwd",UnboundField对象)]

        if cls._wtforms_meta is None:
            bases = []
            for mro_class in cls.__mro__:   #循环当前类和基类组成的元组
                if ‘Meta‘ in mro_class.__dict__:   #如果类中有Meta类，就把Meta类添加到 bases列表中
                    bases.append(mro_class.Meta)
            cls._wtforms_meta = type(‘Meta‘, tuple(bases), {})    #LoginForm._wtforms_meta = 一个新的Meta类，它继承了所有的Meta类，这样做好处在于：通过新Meta类可以取到无论是LoginForm或者LoginForm基类中的任何Meta类
        return type.__call__(cls, *args, **kwargs)