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']

# coding=utf-8
# Created 2014 by Janusz Skonieczny 

import logging

from flask_wtf import Form
from flask_wtf.form import _Auto
from wtforms_alchemy import model_form_factory


class FormSetupError(Exception):
    pass

BaseModelForm = model_form_factory(base=Form)


class ModelForm(BaseModelForm):
    # model = None

    def __init__(self, formdata=_Auto, obj=None, *args, **kwargs):
        self.obj = obj
        # if not self.Meta.model:
        #     self.Meta.model = kwargs.pop("model", None)
        # self.parent = kwargs.pop("parent", None)
        super(ModelForm, self).__init__(formdata=formdata, obj=obj, *args, **kwargs)

    def save(self):
        dbs = self.get_session()
        if not self.obj:
            if not self.Meta.model:
                FormSetupError("Model was not configured, please setup property or provide model during init")

                                    QuerySelectMultipleField)
from wtforms_components import read_only
from wtforms_components import DateIntervalField
from wtforms_components.widgets import ReadOnlyWidgetProxy
from wtforms.validators import Required
from flask_ppt2 import app, db
import flask_ppt2.alchemy_models as alch
from config.settings_dev import (FISCAL_YEAR_FORMAT, YEAR_RANGE_MIN,
                                 YEAR_RANGE_MAX, FISCAL_QUARTERS)
YEAR_RANGE_MIN = 2004


if os.environ["PPT_ENVIRONMENT"] == "dev":
    import pydevd

BaseModelForm = model_form_factory(FlaskForm)

FISCAL_YEAR_OFFSET = app.config.get("FISCAL_YEAR_OFFSET")
FISCAL_QUARTERS = app.config.get("FISCAL_QUARTERS")
YEAR_RANGE_MIN = app.config.get("YEAR_RANGE_MIN")
YEAR_RANGE_MAX = app.config.get("YEAR_RANGE_MAX")

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


class FormlyAttributes:
    """Mixin class for forms to generate a list of form field descriptions.

# coding=utf-8

from abilian.web.forms import Form
from abilian.web.forms import widgets as abilian_widgets
from abilian.web.forms.fields import QuerySelect2Field
from abilian.web.forms.filters import strip
from abilian.web.forms.validators import optional, required
from flask_babel import lazy_gettext as _l
from wtforms import StringField, TextAreaField
from wtforms_alchemy import model_form_factory

from abilian.sbe.apps.communities.models import Community

ModelForm = model_form_factory(Form)  # type: Form


class UserProfileForm(ModelForm):
    pass


class UserProfileViewForm(UserProfileForm):
    communautes = QuerySelect2Field(
        "Communautés d'appartenance",
        get_label="name",
        view_widget=abilian_widgets.ListWidget(),
        query_factory=lambda: Community.query.all(),
        multiple=True,
        validators=[optional()],
    )

 def test_unique_validator(self):
     form = model_form_factory(unique_validator=None)
     assert form.Meta.unique_validator is None

 def test_custom_base_with_session(self):
     cls = model_form_factory(self.Base)
     assert cls.get_session() == 'TestSession'