class ExitSurvey2Form(wtf.Form):
book_format = MultiCheckboxField(
"Which book format(s) did you use?<br>Check all that apply.",
choices=(
('book-7th', 'Hard copy of Popham (Seventh Edition)'),
('book-6th', 'Hard copy of Popham (Sixth Edition)'),
('book-5th', 'Hard copy of Popham (Fifth Edition)'),
('ebook', 'E-text of Popham'),
('other-online', 'Other Online Resources (please explain)'),
('no-book', 'I did not use the book (please explain)'),
),
validators=[wtf.validators.required()])
book_format_explain = wtf.StringField(
validators=[wtf.validators.optional()])
required_to_take = wtf.RadioField(
"Were you required by someone to complete this course? If so, please explain.",
choices=(
('yes', 'Yes'),
('no', 'No'),
),
widget=HorizontalWidget('div'),
validators=[wtf.validators.required()])
required_to_take_explain = wtf.StringField(
validators=[wtf.validators.optional()])
professional_development = wtf.RadioField(
"""Did this course count towards a professional development
requirement for your job? If so, please explain.""",
choices=(
('yes', 'Yes'),
('no', 'No'),
),
widget=HorizontalWidget('div'),
validators=[wtf.validators.required()])
professional_development_explain = wtf.StringField(
validators=[wtf.validators.optional()])
# TODO professional role
shared_any_badges = wtf.RadioField(
"""Did you share any digital badges from this course? If so, describe your experience.""",
choices=(
('yes', 'Yes'),
('no', 'No'),
),
widget=HorizontalWidget('div'),
validators=[wtf.validators.required()])
shared_badges_experience = wtf.TextAreaField(
validators=[wtf.validators.optional()])
claimed_badges_mozilla = wtf.RadioField(
"""Did you claim any badges on Mozilla OBI from this course?""",
choices=(
('yes', 'Yes'),
('no', 'No'),
),
widget=HorizontalWidget('div'),
validators=[wtf.validators.required()])
course_badges_price = wtf.StringField(
"""Now that you have taken the course, how much do you think you
might have paid to take the course and earn digital badges?""",
validators=[wtf.validators.required()])
certificate_price = wtf.StringField(
"""Now that you have taken the course, how much do you think you
might have paid to earn the instructor verified Certificate?""",
validators=[wtf.validators.required()])
class ServiceForm(wtforms.Form):
# adds some more fields to Contact form
name = wtforms.StringField('Name', validators = [InputRequired()])
email = wtforms.StringField('Email', validators = [Email(), InputRequired()])
phone = wtforms.StringField('Phone Number')
overview = wtforms.TextField('Project Overview', validators=[InputRequired()])
class CMSNameForm(BaseForm):
name = wtforms.StringField(validators=[
wtforms.validators.Length(min=1, max=20),
wtforms.validators.InputRequired(message=u'名称不能为空！')
])
class NameForm(FlaskForm):
name = wtforms.StringField('what is your name?', validators = [DataRequired()])
submit = wtforms.SubmitField('Submit')
class AuthUpdateForm(flask_wtf.FlaskForm):
bitbucket_key = wtforms.StringField(
model.Config.bitbucket_key._verbose_name, filters=[util.strip_filter])
bitbucket_secret = wtforms.StringField(
model.Config.bitbucket_secret._verbose_name,
filters=[util.strip_filter])
facebook_app_id = wtforms.StringField(
model.Config.facebook_app_id._verbose_name,
filters=[util.strip_filter])
facebook_app_secret = wtforms.StringField(
model.Config.facebook_app_secret._verbose_name,
filters=[util.strip_filter])
github_client_id = wtforms.StringField(
model.Config.github_client_id._verbose_name,
filters=[util.strip_filter])
github_client_secret = wtforms.StringField(
model.Config.github_client_secret._verbose_name,
filters=[util.strip_filter])
google_client_id = wtforms.StringField(
model.Config.google_client_id._verbose_name,
filters=[util.strip_filter])
google_client_secret = wtforms.StringField(
model.Config.google_client_secret._verbose_name,
filters=[util.strip_filter])
microsoft_client_id = wtforms.StringField(
model.Config.microsoft_client_id._verbose_name,
filters=[util.strip_filter])
microsoft_client_secret = wtforms.StringField(
model.Config.microsoft_client_secret._verbose_name,
filters=[util.strip_filter])
twitter_consumer_key = wtforms.StringField(
model.Config.twitter_consumer_key._verbose_name,
filters=[util.strip_filter])
twitter_consumer_secret = wtforms.StringField(
model.Config.twitter_consumer_secret._verbose_name,
filters=[util.strip_filter])
class CommentForm(BaseForm):
post_id = wtforms.IntegerField(validators=[validators.InputRequired(message=u'请填入帖子信息！')])
content = wtforms.StringField(validators=[validators.InputRequired(message=u'请填入帖子内容！')])
comment_id = wtforms.IntegerField()
class Register(flask_wtf.FlaskForm):
username = wtforms.StringField(
label="Username",
validators=[
validators.Regexp(
regex="^\w+$", # noqa
message="Username contains invalid characters.",
),
validators.InputRequired(message="Please enter a username."),
validators.Length(
min=4,
max=64,
message="Username must between 4 and 64 characters long.",
),
custom_validators.IUnique(
model=models.Account,
field=models.Account.username,
message="This username already exists.",
),
],
)
display = wtforms.StringField(
label="Display name",
validators=[
validators.Length(
max=100,
message="Display name must be less than 100 characters long.",
),
],
)
email = wtforms.StringField(
label="Email",
validators=[
validators.InputRequired(message="Please enter an email address."),
validators.Email(message="Please enter a valid email address."),
validators.Length(
min=4,
max=120,
message="Email must be between 4 and 120 characters long.",
),
custom_validators.IUnique(
model=models.Account,
field=models.Account.email,
message="This email already exists.",
),
],
)
password = wtforms.PasswordField(
label="Password",
validators=[
validators.InputRequired(message="Please enter your password."),
validators.Length(
min=8,
max=255,
message="Password must be between 8 and 255 characters long.",
),
],
)
confirm_password = wtforms.PasswordField(
label="Confirm password",
validators=[
validators.InputRequired(message="Please re-enter your password."),
validators.EqualTo(
fieldname="password", message="Passwords do not match."
),
],
)
submit = wtforms.SubmitField(label="Submit")
class AuthTokenCreateForm(ReactorForm):
description = wtforms.StringField(_('Token description'))
expires = wtforms.SelectField('Expires',
coerce=lambda x: x,
choices=time_choices,
validators=[wtforms.validators.Optional()])
import wtforms
import flask_wtf
def AddContactForm(flask_wtf.FlaskForm):
name = wtforms.StringField("name")
phone = wtforms.StringField("Phone:")
submit = wtforms.SubmitField("Add contact")
class WebAuthnCredentialMixin:
credential = wtforms.StringField(wtforms.validators.DataRequired())
class RecoveryCodeValueMixin:
recovery_code_value = wtforms.StringField(
validators=[wtforms.validators.DataRequired()])
class LostPwdForm(flask_wtf.FlaskForm):
email = wtf.StringField('Email')
submit = wtf.SubmitField('Send a password recovery email')
class UrlForm(FlaskForm):
content = wtforms.StringField('Url', validators=[DataRequired(), URL()])
class LikertItemForm(wtf.Form):
rating = wtf.RadioField(**likert_kwargs)
comment = wtf.StringField(**comment_kwargs)
class AddSlotForm(flask_wtf.FlaskForm):
#Login required
t_start = wtforms.StringField("Lecture Start Time (in HH:MM:SS)", validators=[DataRequired()])
t_end = wtforms.StringField("Lecture End Time (in HH:MM:SS)", validators=[DataRequired()])
day = wtforms.StringField("Day", validators=[DataRequired()])
submit = wtforms.SubmitField("Register")
class UserResetForm(flask_wtf.FlaskForm):
new_password = wtforms.StringField(
'New Password',
[wtforms.validators.required(), wtforms.validators.length(min=6)],
)
class AddLectureForm(flask_wtf.FlaskForm):
#Login required
lnum = wtforms.IntegerField("Lecture Number", validators=[DataRequired()])
quota = wtforms.IntegerField("Quota", validators=[DataRequired()])
deadline = wtforms.StringField("Deadline (in YYYY-MM-DD HH:MM:SS)", validators=[DataRequired()])
submit = wtforms.SubmitField("Register")
class NewUserForm(FlaskForm):
name = wtf.StringField("Name")
age = wtf.IntegerField("Age")
submit = wtf.SubmitField("Create user")
class AuthUpdateForm(wtf.Form):
bitbucket_key = wtforms.StringField(
model.Config.bitbucket_key._verbose_name, filters=[util.strip_filter])
bitbucket_secret = wtforms.StringField(
model.Config.bitbucket_secret._verbose_name,
filters=[util.strip_filter])
dropbox_app_key = wtforms.StringField(
model.Config.dropbox_app_key._verbose_name,
filters=[util.strip_filter])
dropbox_app_secret = wtforms.StringField(
model.Config.dropbox_app_secret._verbose_name,
filters=[util.strip_filter])
facebook_app_id = wtforms.StringField(
model.Config.facebook_app_id._verbose_name,
filters=[util.strip_filter])
facebook_app_secret = wtforms.StringField(
model.Config.facebook_app_secret._verbose_name,
filters=[util.strip_filter])
github_client_id = wtforms.StringField(
model.Config.github_client_id._verbose_name,
filters=[util.strip_filter])
github_client_secret = wtforms.StringField(
model.Config.github_client_secret._verbose_name,
filters=[util.strip_filter])
google_client_id = wtforms.StringField(
model.Config.google_client_id._verbose_name,
filters=[util.strip_filter])
google_client_secret = wtforms.StringField(
model.Config.google_client_secret._verbose_name,
filters=[util.strip_filter])
instagram_client_id = wtforms.StringField(
model.Config.instagram_client_id._verbose_name,
filters=[util.strip_filter])
instagram_client_secret = wtforms.StringField(
model.Config.instagram_client_secret._verbose_name,
filters=[util.strip_filter])
linkedin_api_key = wtforms.StringField(
model.Config.linkedin_api_key._verbose_name,
filters=[util.strip_filter])
linkedin_secret_key = wtforms.StringField(
model.Config.linkedin_secret_key._verbose_name,
filters=[util.strip_filter])
microsoft_client_id = wtforms.StringField(
model.Config.microsoft_client_id._verbose_name,
filters=[util.strip_filter])
microsoft_client_secret = wtforms.StringField(
model.Config.microsoft_client_secret._verbose_name,
filters=[util.strip_filter])
reddit_client_id = wtforms.StringField(
model.Config.reddit_client_id._verbose_name,
filters=[util.strip_filter])
reddit_client_secret = wtforms.StringField(
model.Config.reddit_client_secret._verbose_name,
filters=[util.strip_filter])
twitter_consumer_key = wtforms.StringField(
model.Config.twitter_consumer_key._verbose_name,
filters=[util.strip_filter])
twitter_consumer_secret = wtforms.StringField(
model.Config.twitter_consumer_secret._verbose_name,
filters=[util.strip_filter])
vk_app_id = wtforms.StringField(model.Config.vk_app_id._verbose_name,
filters=[util.strip_filter])
vk_app_secret = wtforms.StringField(
model.Config.vk_app_secret._verbose_name, filters=[util.strip_filter])
yahoo_consumer_key = wtforms.StringField(
model.Config.yahoo_consumer_key._verbose_name,
filters=[util.strip_filter])
yahoo_consumer_secret = wtforms.StringField(
model.Config.yahoo_consumer_secret._verbose_name,
filters=[util.strip_filter])
class LoginForm(FlaskForm):
username = wtforms.StringField(
'Username', validators=[wtforms.validators.DataRequired()])
password = wtforms.PasswordField(
'Password', validators=[wtforms.validators.DataRequired()])
submit = wtforms.SubmitField('Login')
class SearchInput(FlaskForm):
name = wtforms.StringField('name_label')
number = wtforms.StringField('phone_label')
submit = wtforms.SubmitField('search_label')
class ModelForm(Form):
### Methods
def selection_exists_in_choices(form, field):
found = False
for choice in field.choices:
if choice[0] == field.data:
found = True
if not found:
raise validators.ValidationError("Selected job doesn't exist. Maybe it was deleted by another user.")
def validate_NetParameter(form, field):
pb = caffe_pb2.NetParameter()
try:
text_format.Merge(field.data, pb)
except text_format.ParseError as e:
raise validators.ValidationError('Not a valid NetParameter: %s' % e)
### Fields
# The options for this get set in the view (since they are dynamic)
dataset = utils.forms.SelectField('Select Dataset', choices=[],
tooltip = "Choose the dataset to use for this model."
)
train_epochs = utils.forms.IntegerField('Training epochs',
validators = [
validators.NumberRange(min=1)
],
default=30,
tooltip = "How many passes through the training data?"
)
snapshot_interval = utils.forms.FloatField('Snapshot interval (in epochs)',
default = 1,
validators = [
validators.NumberRange(min=0),
],
tooltip = "How many epochs of training between taking a snapshot?"
)
val_interval = utils.forms.FloatField('Validation interval (in epochs)',
default = 1,
validators = [
validators.NumberRange(min=0)
],
tooltip = "How many epochs of training between running through one pass of the validation data?"
)
random_seed = utils.forms.IntegerField('Random seed',
validators = [
validators.NumberRange(min=0),
validators.Optional(),
],
tooltip = "If you provide a random seed, then back-to-back runs with the same model and dataset should give identical results."
)
batch_size = utils.forms.IntegerField('Batch size',
validators = [
validators.NumberRange(min=1),
validators.Optional(),
],
tooltip = "How many images to process at once. If blank, values are used from the network definition."
)
### Solver types
solver_type = utils.forms.SelectField('Solver type',
choices = [
('SGD', 'Stochastic gradient descent (SGD)'),
('ADAGRAD', 'Adaptive gradient (AdaGrad)'),
('NESTEROV', "Nesterov's accelerated gradient (NAG)"),
],
default = 'SGD',
tooltip = "What type of solver will be used??"
)
### Learning rate
learning_rate = utils.forms.FloatField('Base Learning Rate',
default = 0.01,
validators = [
validators.NumberRange(min=0),
],
tooltip = "Affects how quickly the network learns. If you are getting NaN for your loss, you probably need to lower this value."
)
lr_policy = wtforms.SelectField('Policy',
choices = [
('fixed', 'Fixed'),
('step', 'Step Down'),
('multistep', 'Step Down (arbitrary steps)'),
('exp', 'Exponential Decay'),
('inv', 'Inverse Decay'),
('poly', 'Polynomial Decay'),
('sigmoid', 'Sigmoid Decay'),
],
default = 'step'
)
lr_step_size = wtforms.FloatField('Step Size',
default = 33
)
lr_step_gamma = wtforms.FloatField('Gamma',
default = 0.1
)
lr_multistep_values = wtforms.StringField('Step Values',
default = "50,85"
)
def validate_lr_multistep_values(form, field):
if form.lr_policy.data == 'multistep':
for value in field.data.split(','):
try:
float(value)
except ValueError:
raise validators.ValidationError('invalid value')
lr_multistep_gamma = wtforms.FloatField('Gamma',
default = 0.5
)
lr_exp_gamma = wtforms.FloatField('Gamma',
default = 0.95
)
lr_inv_gamma = wtforms.FloatField('Gamma',
default = 0.1
)
lr_inv_power = wtforms.FloatField('Power',
default = 0.5
)
lr_poly_power = wtforms.FloatField('Power',
default = 3
)
lr_sigmoid_step = wtforms.FloatField('Step',
default = 50
)
lr_sigmoid_gamma = wtforms.FloatField('Gamma',
default = 0.1
)
### Network
# Use a SelectField instead of a HiddenField so that the default value
# is used when nothing is provided (through the REST API)
method = wtforms.SelectField(u'Network type',
choices = [
('standard', 'Standard network'),
('previous', 'Previous network'),
('custom', 'Custom network'),
],
default='standard',
)
# The options for this get set in the view (since they are dependent on the data type)
standard_networks = wtforms.RadioField('Standard Networks',
validators = [
validate_required_iff(method='standard'),
],
)
previous_networks = wtforms.RadioField('Previous Networks',
choices = [],
validators = [
validate_required_iff(method='previous'),
selection_exists_in_choices,
],
)
custom_network = utils.forms.TextAreaField('Custom Network',
validators = [
validate_required_iff(method='custom'),
validate_NetParameter,
],
)
custom_network_snapshot = utils.forms.TextField('Pretrained model',
tooltip = "Path to pretrained model file. Only edit this field if you understand how fine-tuning works in caffe"
)
def validate_custom_network_snapshot(form, field):
if form.method.data == 'custom':
snapshot = field.data.strip()
if snapshot:
if not os.path.exists(snapshot):
raise validators.ValidationError('File does not exist')
# Select one of several GPUs
select_gpu = wtforms.RadioField('Select which GPU you would like to use',
choices = [('next', 'Next available')] + [(
index,
'#%s - %s%s' % (
index,
get_device(index).name,
' (%s memory)' % sizeof_fmt(get_nvml_info(index)['memory']['total'])
if get_nvml_info(index) and 'memory' in get_nvml_info(index) else '',
),
) for index in config_value('gpu_list').split(',') if index],
default = 'next',
)
# Select N of several GPUs
select_gpus = utils.forms.SelectMultipleField('Select which GPU[s] you would like to use',
choices = [(
index,
'#%s - %s%s' % (
index,
get_device(index).name,
' (%s memory)' % sizeof_fmt(get_nvml_info(index)['memory']['total'])
if get_nvml_info(index) and 'memory' in get_nvml_info(index) else '',
),
) for index in config_value('gpu_list').split(',') if index],
tooltip = "The job won't start until all of the chosen GPUs are available."
)
# XXX For testing
# The Flask test framework can't handle SelectMultipleFields correctly
select_gpus_list = wtforms.StringField('Select which GPU[s] you would like to use (comma separated)')
def validate_select_gpus(form, field):
if form.select_gpus_list.data:
field.data = form.select_gpus_list.data.split(',')
# Use next available N GPUs
select_gpu_count = wtforms.IntegerField('Use this many GPUs (next available)',
validators = [
validators.NumberRange(min=1, max=len(config_value('gpu_list').split(',')))
],
default = 1,
)
def validate_select_gpu_count(form, field):
if field.data is None:
if form.select_gpus.data:
# Make this field optional
field.errors[:] = []
raise validators.StopValidation()
model_name = utils.forms.StringField('Model Name',
validators = [
validators.DataRequired()
],
tooltip = "An identifier, later used to refer to this model in the Application."
)
class CookbookForm(flask_wtf.FlaskForm):
name = wtforms.StringField("Cookbook name",
validators=[wtforms.validators.DataRequired()])
recipes = wtforms.SelectMultipleField(
"Recipes", validators=[wtforms.validators.DataRequired()])
submit = wtforms.SubmitField("Create")
class MetadataForm(forms.Form):
# Metadata version
metadata_version = wtforms.StringField(
description="Metadata-Version",
validators=[
wtforms.validators.DataRequired(),
wtforms.validators.AnyOf(
# Note: This isn't really Metadata 2.0, however bdist_wheel
# claims it is producing a Metadata 2.0 metadata when in
# reality it's more like 1.2 with some extensions.
["1.0", "1.1", "1.2", "2.0", "2.1"],
message="Unknown Metadata Version",
),
],
)
# Identity Project and Release
name = wtforms.StringField(
description="Name",
validators=[
wtforms.validators.DataRequired(),
wtforms.validators.Regexp(
_project_name_re,
re.IGNORECASE,
message=(
"Must start and end with a letter or numeral and contain "
"only ascii numeric and '.', '_' and '-'."),
),
],
)
version = wtforms.StringField(
description="Version",
validators=[
wtforms.validators.DataRequired(),
wtforms.validators.Regexp(
r"^(?!\s).*(?<!\s)$",
message="Cannot have leading or trailing whitespace.",
),
_validate_pep440_version,
],
)
# Additional Release metadata
summary = wtforms.StringField(
description="Summary",
validators=[
wtforms.validators.Optional(),
wtforms.validators.Length(max=512),
wtforms.validators.Regexp(
r"^.+$", # Rely on the fact that . doesn't match a newline.
message="Multiple lines are not allowed.",
)
],
)
description = wtforms.StringField(
description="Description",
validators=[wtforms.validators.Optional()],
)
author = wtforms.StringField(
description="Author",
validators=[wtforms.validators.Optional()],
)
description_content_type = wtforms.StringField(
description="Description-Content-Type",
validators=[
wtforms.validators.Optional(),
_validate_description_content_type,
],
)
author_email = wtforms.StringField(
description="Author-email",
validators=[
wtforms.validators.Optional(),
_validate_rfc822_email_field,
],
)
maintainer = wtforms.StringField(
description="Maintainer",
validators=[wtforms.validators.Optional()],
)
maintainer_email = wtforms.StringField(
description="Maintainer-email",
validators=[
wtforms.validators.Optional(),
_validate_rfc822_email_field,
],
)
license = wtforms.StringField(
description="License",
validators=[wtforms.validators.Optional()],
)
keywords = wtforms.StringField(
description="Keywords",
validators=[wtforms.validators.Optional()],
)
classifiers = wtforms.fields.SelectMultipleField(
description="Classifier", )
platform = wtforms.StringField(
description="Platform",
validators=[wtforms.validators.Optional()],
)
# URLs
home_page = wtforms.StringField(
description="Home-Page",
validators=[
wtforms.validators.Optional(),
forms.URIValidator(),
],
)
download_url = wtforms.StringField(
description="Download-URL",
validators=[
wtforms.validators.Optional(),
forms.URIValidator(),
],
)
# Dependency Information
requires_python = wtforms.StringField(
description="Requires-Python",
validators=[
wtforms.validators.Optional(),
_validate_pep440_specifier_field,
],
)
# File information
pyversion = wtforms.StringField(validators=[wtforms.validators.Optional()
], )
filetype = wtforms.StringField(validators=[
wtforms.validators.DataRequired(),
wtforms.validators.AnyOf(
[
"bdist_dmg",
"bdist_dumb",
"bdist_egg",
"bdist_msi",
"bdist_rpm",
"bdist_wheel",
"bdist_wininst",
"sdist",
],
message="Unknown type of file.",
),
])
comment = wtforms.StringField(validators=[wtforms.validators.Optional()], )
md5_digest = wtforms.StringField(validators=[
wtforms.validators.Optional(),
], )
sha256_digest = wtforms.StringField(validators=[
wtforms.validators.Optional(),
wtforms.validators.Regexp(
r"^[A-F0-9]{64}$",
re.IGNORECASE,
message="Must be a valid, hex encoded, SHA256 message digest.",
),
], )
blake2_256_digest = wtforms.StringField(validators=[
wtforms.validators.Optional(),
wtforms.validators.Regexp(
r"^[A-F0-9]{64}$",
re.IGNORECASE,
message="Must be a valid, hex encoded, blake2 message digest.",
),
], )
# Legacy dependency information
requires = ListField(validators=[
wtforms.validators.Optional(),
_validate_legacy_non_dist_req_list,
], )
provides = ListField(validators=[
wtforms.validators.Optional(),
_validate_legacy_non_dist_req_list,
], )
obsoletes = ListField(validators=[
wtforms.validators.Optional(),
_validate_legacy_non_dist_req_list,
], )
# Newer dependency information
requires_dist = ListField(
description="Requires-Dist",
validators=[
wtforms.validators.Optional(),
_validate_legacy_dist_req_list,
],
)
provides_dist = ListField(
description="Provides-Dist",
validators=[
wtforms.validators.Optional(),
_validate_legacy_dist_req_list,
],
)
obsoletes_dist = ListField(
description="Obsoletes-Dist",
validators=[
wtforms.validators.Optional(),
_validate_legacy_dist_req_list,
],
)
requires_external = ListField(
description="Requires-External",
validators=[
wtforms.validators.Optional(),
_validate_requires_external_list,
],
)
# Newer metadata information
project_urls = ListField(
description="Project-URL",
validators=[
wtforms.validators.Optional(),
_validate_project_url_list,
],
)
def full_validate(self):
# All non source releases *must* have a pyversion
if (self.filetype.data and self.filetype.data != "sdist"
and not self.pyversion.data):
raise wtforms.validators.ValidationError(
"Python version is required for binary distribution uploads.")
# All source releases *must* have a pyversion of "source"
if self.filetype.data == "sdist":
if not self.pyversion.data:
self.pyversion.data = "source"
elif self.pyversion.data != "source":
raise wtforms.validators.ValidationError(
"The only valid Python version for a sdist is 'source'.")
# We *must* have at least one digest to verify against.
if not self.md5_digest.data and not self.sha256_digest.data:
raise wtforms.validators.ValidationError(
"Must include at least one message digest.", )
class ContactForm(wtforms.Form):
name = wtforms.StringField('Name', validators = [InputRequired()])
email = wtforms.StringField('Email', validators = [Email(), InputRequired()])
phone = wtforms.StringField('Phone Number')
message = wtforms.TextField('Message', validators=[InputRequired(), Length(min=20)])
class HoneypotMixin:
""" A mixin to catch spammers. This field should always be blank """
confirm_form = wtforms.StringField()
class CMSAddBoardForm(BaseForm):
name = wtforms.StringField(validators=[
wtforms.validators.Length(min=1, max=20),
wtforms.validators.InputRequired()
])
class LoginForm(FlaskForm):
login = wtforms.StringField('login', validators=[wtforms.validators.DataRequired()])
password = wtforms.PasswordField('password', validators=[wtforms.validators.DataRequired()])
class CMSStringIdForm(BaseForm):
id = wtforms.StringField(
validators=[wtforms.validators.InputRequired(message=u'id不能为空！')])
class SignupForm(flask_wtf.FlaskForm):
username = wtforms.StringField("Name:", validators=[vld.DataRequired()])
password = wtforms.PasswordField("Password:"******"Sign up")
