Python wtforms_alchemy.model_form_factory函数代码示例

    def test_throws_exception_for_unknown_configuration_option(self):
        self.init()

        class SomeForm(Form):
            pass

        defaults = {"unknown": "something"}
        with raises(UnknownConfigurationOption):
            model_form_factory(SomeForm, **defaults)

    def get_form_class(self):
        """
        Returns the form class to use in this view.
        """
        if self.form_class:
            return self.form_class
        else:
            if self.model is not None:
                # If a model has been explicitly provided, use it
                model = self.model
            elif hasattr(self, 'object') and self.object is not None:
                # If this view is operating on a single object, use
                # the class of that object
                model = self.object.__class__
            else:
                # Try to get a query and extract the model class
                # from that
                model = get_model_from_obj(self.get_query())

            # Create a new class to use as the base. We do this to ensure
            # Meta.model is available when the form is generated by the factory.
            model_ = model
            class ModelFormWithModel(ModelForm):
                class Meta:
                    model = model_
                    only = self.fields
            model_form = model_form_factory(ModelFormWithModel)
            model_form.Meta.model = model
            return model_form

    def test_inherit_with_new_session(self):
        cls = model_form_factory(self.Base)

        class Sub(cls):
            @classmethod
            def get_session(self):
                return 'SubTestSession'
        assert Sub.get_session() == 'SubTestSession'

    def test_raises_exception_if_no_session_set_for_unique_validators(self):
        class ModelTest(self.base):
            __tablename__ = 'model_test'
            id = sa.Column(sa.Integer, primary_key=True)
            test_column = sa.Column(sa.Unicode(255), unique=True)

        Form = model_form_factory()
        assert not Form.get_session

        with raises(Exception):
            class ModelTestForm(Form):
                class Meta:
                    model = ModelTest

    def test_supports_parameter_overriding(self):
        self.init()

        class MyFormGenerator(FormGenerator):
            pass

        defaults = {
            "all_fields_optional": True,
            "only_indexed_fields": True,
            "include_primary_keys": True,
            "include_foreign_keys": True,
            "strip_string_fields": True,
            "include_datetimes_with_default": True,
            "form_generator": True,
            "date_format": "%d-%m-%Y",
            "datetime_format": "%Y-%m-%dT%H:%M:%S",
        }
        ModelForm = model_form_factory(Form, **defaults)
        for key, value in defaults.items():
            assert getattr(ModelForm.Meta, key) == value

 def test_optional_validator(self):
     form = model_form_factory(optional_validator=None)
     assert form.Meta.optional_validator is None

 def test_time_range_validator(self):
     form = model_form_factory(time_range_validator=None)
     assert form.Meta.time_range_validator is None

 def test_number_range_validator(self):
     form = model_form_factory(number_range_validator=None)
     assert form.Meta.number_range_validator is None

__version__ = '0.1.0'

from flask.ext.wtf import Form
import wtforms
from wtforms_alchemy import model_form_factory

from ..database import db


BaseModelForm = model_form_factory(Form)


class ModelForm(BaseModelForm):
    """
    wtforms-alchemy Flask-WTF compatible base model form.
    Copied from:
    http://wtforms-alchemy.readthedocs.org/en/latest/advanced.html#using-wtforms-alchemy-with-flask-wtf
    """

    @classmethod
    def get_session(self):
        return db.session


BaseModelWtfForm = model_form_factory(wtforms.Form)


class ModelWtfForm(BaseModelWtfForm):
    """
    Same as ModelForm (also defined in this file), but inherited
    from regular wtforms base class, instead of Flask-WTF base

 def test_custom_base_without_session(self):
     cls = model_form_factory(Form)
     assert cls.get_session is None

    此函数把这些无法被处理的值转换成每种字段对应的字符串形式"""
    if value is None:
        return ''
    if isinstance(value, datetime.datetime):
        return value.isoformat().split(".").pop(0)
    if isinstance(value, int) or isinstance(value, float):
        # 若不把数字类型转换为 str ，InputValidator() 会把 0 值视为未赋值，导致验证失败
        return str(value)
    return value


# ======================================
#    自定义 WTForms-alchemy ModelForm
# ======================================

ModelForm = model_form_factory(APIForm, strip_string_fields=True)


class _APIEditForm(APIForm):
    def __init__(self, *args, **kwargs):
        if not hasattr(self, '_obj'):
            raise ValueError(u"""当前表单是编辑实体用的表单，应传入对应的实体对象以避免 unique 检查失败。
                请通过命名参数的形式传递，即： TheForm(obj=instance) ，不要直接传递。
                如果确实不需要传入 obj 参数，请这样： TheForm(obj=None)""")
        super(_APIEditForm, self).__init__(*args, **kwargs)


ModelEditForm = model_form_factory(_APIEditForm,
                                   strip_string_fields=True,
                                   all_fields_optional=True)

import flask_wtf
import wtforms_alchemy
from flask_skeleton.models import db, User


class DeleteForm(flask_wtf.Form):
    """Dummy form to allow CSRF on requests without other fields, e.g. delete."""
    pass

# plumbing to get flask integration between wtforms_alchemy and flask_wtf
# pylint: disable=invalid-name
BaseModelForm = wtforms_alchemy.model_form_factory(flask_wtf.Form)


class ModelForm(BaseModelForm):
    @classmethod
    def get_session(self):
        return db.session


class UserForm(ModelForm):
    class Meta:
        model = User
        only = ['email', 'password']

def model_form_custom(request):
    """Returns one of each possible model form classes with custom
    metaclasses."""
    return model_form_factory(meta=request.param)

def model_form_all(request):
    """Returns one of each possible model form classes with custom and the
    original metaclass."""
    ModelForm = model_form_factory(meta=request.param)
    return ModelForm

#
# Lifewatch DAAP is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Lifewatch DAAP is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Lifewatch DAAP. If not, see <http://www.gnu.org/licenses/>.

from __future__ import absolute_import, print_function, unicode_literals

from invenio.utils.forms import InvenioBaseForm

from wtforms_alchemy import model_form_factory
from .models import UserProfile

ModelForm = model_form_factory(InvenioBaseForm)


class ProfileForm(ModelForm):
    class Meta:
        model = UserProfile
        only = ['name', 'institution', 'email', 'social_profiles',
                'ssh_public_key', 'user_db', 'pass_db',
                'token_onedata']