class RestaurantForm(FlaskForm):
name = f.StringField('Name', validators=[DataRequired()])
lat = f.FloatField('Latitude', validators=[DataRequired()])
lon = f.FloatField('Longitude', validators=[DataRequired()])
phone = f.StringField('Phone', validators=[DataRequired()])
# Note: the capacity is automatically derived from tables settings
cuisine_type = f.SelectMultipleField(
'Cuisine types',
choices = Restaurant.CUISINE_TYPES.choices(),
coerce = Restaurant.CUISINE_TYPES.coerce,
validators=[DataRequired()]
)
prec_measures = f.TextAreaField('Precautionary measures',validators=[DataRequired()])
avg_time_of_stay = f.IntegerField('Average time of stay (in minutes)', validators=[DataRequired(), NumberRange(min=15)])
workingdays = f.FieldList(f.FormField(WorkingDayForm), min_entries=1, max_entries=7)
tables = f.FieldList(f.FormField(TableForm), min_entries=1, max_entries=100)
dishes = f.FieldList(f.FormField(DishForm), min_entries=1, max_entries=100)
display = ['name', 'lat', 'lon', 'phone', 'cuisine_type', 'prec_measures', 'avg_time_of_stay']
def validate_workingdays(form, field):
days_already_added = []
for wd in field.data:
if wd['day'] in days_already_added:
raise ValidationError("There cannot be two working days with the same day")
else:
days_already_added.append(wd['day'])
class CreateModuleForm(wtf.Form):
name = wtforms.StringField("Name")
version = wtforms.StringField("Version")
release = wtforms.StringField("Release")
filter = wtforms.FieldList(wtforms.StringField("Package Filter"))
api = wtforms.FieldList(wtforms.StringField("Module API"))
profile_names = wtforms.FieldList(wtforms.StringField("Install Profiles"),
min_entries=2)
profile_pkgs = wtforms.FieldList(wtforms.FieldList(
wtforms.StringField("Install Profiles")),
min_entries=2)
def validate(self):
if not wtf.Form.validate(self):
return False
# Profile names should be unique
names = filter(None, self.profile_names.data)
if len(set(names)) < len(names):
self.errors["profiles"] = ["Profile names must be unique"]
return False
# WORKAROUND
# profile_pkgs are somehow sorted so if I fill profile_name in the first box and
# profile_pkgs in seconds box, it is sorted and validated correctly
for i in range(0, len(self.profile_names.data)):
# If profile name is not set, then there should not be any packages in this profile
if not flask.request.form["profile_names-{}".format(i)]:
if [
j for j in range(0, len(self.profile_names)) if
"profile_pkgs-{}-{}".format(i, j) in flask.request.form
]:
self.errors["profiles"] = ["Missing profile name"]
return False
return True
class RecipeEdit(Form):
START_NUM_INGREDIENTS = RECIPE_START_NUM_INGREDIENTS
MIN_INGREDIENTS = RECIPE_MIN_INGREDIENTS
MIN_GROUPS = RECIPE_MIN_GROUPS
title = wtf.TextField("Title")
description = wtf.TextAreaField("Description")
instructions = wtf.TextAreaField("Instructions")
photo = wtf.FileField("Photo", validators=[valid_photo])
tags = TagListField("Tags", validators=[valid_tags])
general_ingredients = wtf.FieldList(wtf.FormField(IngredientForm),
min_entries=RECIPE_MIN_INGREDIENTS,
max_entries=RECIPE_MAX_INGREDIENTS)
ingredient_groups = wtf.FieldList(wtf.FormField(IngredientGroup),
min_entries=RECIPE_MIN_GROUPS,
max_entries=RECIPE_MAX_GROUPS)
@classmethod
def from_recipe(cls, recipe, *args, **orig_kwargs):
kwargs = dict(orig_kwargs)
kwargs['title'] = recipe.title
kwargs['description'] = recipe.description
kwargs['instructions'] = recipe.instructions
kwargs['general_ingredients'] = [
IngredientForm.from_model(i) for i in recipe.general_ingredients
]
kwargs['ingredient_groups'] = [
IngredientGroup.from_model(g) for g in recipe.ingredient_groups
]
kwargs['tags'] = recipe.tags
return cls(*args, **kwargs)
def save_recipe(self, recipe):
"""
Update a recipe from the form data
"""
if self.photo.data:
recipe.photo = photos.save(self.photo.data.stream)
recipe.title = self.title.data
recipe.title_slug = slugify(self.title.data)
recipe.description = self.description.data
recipe.instructions = self.instructions.data
recipe.general_ingredients = [
i.to_model() for i in self.general_ingredients
]
recipe.ingredient_groups = [
g.to_model() for g in self.ingredient_groups
]
recipe.tags = self.tags.data
recipe.save()
class NotifyForm(wtforms.Form):
is_tested = wtforms.BooleanField('Is tested against COVID-19', default=False)
comment = wtforms.StringField('Comment', [wtforms.validators.Length(max=1000)])
keys = wtforms.FieldList(wtforms.FormField(DailyKeyForm))
def validate_keys(form, field):
if not field.data:
return
expected_keys_count = INCUBATION_PERIOD + SYMPTOMS_TO_VIRUS_NEGATIVE
key_values = set(key['value'] for key in field.data)
# All keys should be unique, and should match the expected count
if len(key_values) != expected_keys_count:
raise wtforms.ValidationError(
'Should contain {} daily keys.'.format(expected_keys_count)
)
key_dates = sorted(key['date'] for key in field.data)
# There should not be any missing date
prev_date = None
for date in key_dates:
if prev_date is not None and date != prev_date + datetime.timedelta(days=1):
raise wtforms.ValidationError('Key dates should not contain gaps.')
prev_date = date
if key_dates[0] > datetime.datetime.utcnow().date():
raise wtforms.ValidationError('Key dates can not all be in the future.')
class GameForm(wtforms.Form):
"""A form for entering info to start a game."""
num_players = wtforms.IntegerField("How many players?")
set_num_players = wtforms.SubmitField("Go")
roles = wtforms.FieldList(
wtforms.SelectField(choices=role_choices, coerce=int, default=3))
start_phase = wtforms.SelectField("Start phase",
choices=[(0, "Day"), (1, "Night")],
coerce=int,
default=0)
submit = wtforms.SubmitField("Start Game")
def validate_num_players(form, field):
"""Make sure num_players contains an integer that is at least 3.
wtforms.validators.NumberRange isn't good enough because it raises
an error if num_players contains an invalid integer."""
# field.data is None if a proper integer wasn't passed in
if field.data is not None and field.data < 3:
raise wtforms.validators.ValidationError(
"Mafia isn't fun with fewer than 3 players")
def add_role_fields(self, n):
"""Add or remove role fields from this form so that there are
fields for exactly n roles."""
num_players = len(self.roles)
append_or_pop = (self.roles.append_entry
if num_players < n else self.roles.pop_entry)
for i in range(abs(n - num_players)):
append_or_pop()
def attachment_form_group_create(schema_prop):
"""Creates a wtforms.FieldList for attachments."""
file_select_form_group = _attachment_build_single_field(schema_prop)
field = wtforms.FieldList(CustomFormField(file_select_form_group), min_entries=1)
return field
class InstrumentList(wtf.Form):
'''
'''
curve_date = wtffields.DateField('Curve date')
curve_type = wtf.SelectField('Curve type', choices=conv.CURVE_TYPES)
currency = wtf.TextField('Currency')
instruments = wtf.FieldList(wtf.FormField(Instrument), min_entries=3)
submit = wtf.SubmitField()
class PatientForm(Form):
site = ModelField(
dbsession=dbsession,
class_=models.Site,
validators=[
wtforms.validators.InputRequired(),
check_allowed])
references = wtforms.FieldList(wtforms.FormField(ReferenceForm))
class TestForm(TornadoForm):
msg = wtforms.StringField('msg', [validators.Length(min=4, max=23)])
lst = wtforms.FieldList(wtforms.StringField('lst')) # 数组
dit = wtforms.FormField(TelephoneForm) # 字典判断
def validate_msg(self, field):
# 自定义验证器
if field.data != 'hello world':
raise ValidationError(u'Must be hello world')
class VisitForm(Form):
cycles = wtforms.FieldList(ModelField(
db_session=db_session,
class_=models.Cycle,
validators=[wtforms.validators.InputRequired(), unique_cycle]),
min_entries=1)
visit_date = DateField(validators=[
wtforms.validators.InputRequired(),
DateRange(min=date(1900, 1, 1)), unique_visit_date
])
include_forms = wtforms.BooleanField()
include_specimen = wtforms.BooleanField()
class SchemaManagementForm(Form):
schema = wtforms.StringField(validators=[
wtforms.validators.InputRequired(), check_not_patient_schema,
check_not_randomization_schema, check_not_termination_schema
])
versions = wtforms.FieldList(
ModelField(db_session=db_session,
class_=datastore.Schema,
validators=[
wtforms.validators.InputRequired(), check_published
]),
validators=[wtforms.validators.DataRequired(), check_same_schema])
class PostForm(FlaskForm):
user_ids = form.FieldList(form.IntegerField(),
validators=[v.DataRequired()])
message = form.StringField(validators=[v.InputRequired()])
img_url = form.StringField(validators=[v.Optional(), v.URL()])
expire = form.IntegerField(validators=[v.optional(), v.NumberRange(min=0)])
lesson_id = form.IntegerField(validators=[v.Optional()])
show_at = form.DateTimeField(validators=[v.Optional(),
Future()],
format='%d.%m.%Y %H:%M')
class Meta:
csrf = False
class UploadsForm(wtforms.Form):
enctype = ' enctype="multipart/form-data"'
uploads = wtforms.FieldList(wtforms.FormField(UploadForm))
def __init__(self, images=None, *args, **kwargs):
super(UploadsForm, self).__init__(*args, **kwargs)
if not kwargs.get('formdata'):
for image in images or []:
self.uploads.append_entry({'filename': image})
for filename, field in zip(images, self.uploads):
field.label = filename
field.file.label = ''
class ResourceUpdateForm(flask_wtf.FlaskForm):
name = wtforms.TextField(u'عنوان الصورة', [wtforms.validators.required()])
description = wtforms.TextAreaField(u'وصف الصورة',
[wtforms.validators.optional()])
address_first_line = wtforms.TextField(u'عنوان الشارع',
[wtforms.validators.optional()])
address_second_line = wtforms.TextField(u'القرية/الحارة/المنطقة',
[wtforms.validators.optional()])
city = wtforms.TextField(u'المدينة', [wtforms.validators.optional()])
country = wtforms.TextField(u'البلد', [wtforms.validators.optional()])
tags = wtforms.FieldList(wtforms.TextField(u'كلمة وصفية'),
min_entries=2,
label=u'الكلمات الوصفية الحالية')
new_tags = wtforms.TextField(u'كلمات وصفية جديدة (افصل بينهم بفاصلة)')
class FieldForm(Form):
name = wtforms.StringField(
validators=[
wtforms.validators.InputRequired(),
wtforms.validators.Length(min=2, max=100),
wtforms.validators.Regexp(
RE_VALID_NAME,
message=_(u'Not a valid variable name')),
wtforms.validators.NoneOf(
RESERVED_WORDS,
message=_(u'Can\'t use reserved programming word')),
unique_variable])
title = wtforms.StringField(validators=[
wtforms.validators.Optional()])
description = wtforms.StringField(
widget=wtforms.widgets.TextInput(),
validators=[wtforms.validators.Optional()])
type = wtforms.StringField(
validators=[
wtforms.validators.InputRequired(),
wtforms.validators.AnyOf(set(t['name'] for t in types))])
is_required = wtforms.BooleanField(
validators=[wtforms.validators.Optional()])
is_private = wtforms.BooleanField(
validators=[wtforms.validators.Optional()])
is_system = wtforms.BooleanField(
validators=[wtforms.validators.Optional()])
is_readonly = wtforms.BooleanField(
validators=[wtforms.validators.Optional()])
# Choice
is_collection = wtforms.BooleanField(
validators=[wtforms.validators.Optional()])
# Choice
is_shuffled = wtforms.BooleanField(
validators=[wtforms.validators.Optional()])
# Numbers
decimal_places = wtforms.IntegerField(
validators=[wtforms.validators.Optional()])
# Number/String/Multichoice
value_min = wtforms.IntegerField(
validators=[wtforms.validators.Optional()])
# Number/String/Multichoice
value_max = wtforms.IntegerField(
validators=[wtforms.validators.Optional()])
# String
pattern = wtforms.StringField(
validators=[wtforms.validators.Optional()])
choices = wtforms.FieldList(wtforms.FormField(ChoiceForm))
class IngredientGroup(Form):
title = wtf.TextField("Ingredient group name",
validators=[
wtf.validators.Required(
message="Ingredient group name is required")
])
ingredients = wtf.FieldList(wtf.FormField(IngredientForm),
min_entries=RECIPE_MIN_INGREDIENTS,
max_entries=RECIPE_MAX_INGREDIENTS)
def __init__(self, *args, **kwargs):
kwargs['csrf_enabled'] = False
super(IngredientGroup, self).__init__(*args, **kwargs)
@staticmethod
def from_model(ingredient_group):
"""
Convert ingredient group model to dictionary of
values used for filling out form data
"""
return {
'title':
ingredient_group.title,
'ingredients': [
IngredientForm.from_model(i)
for i in ingredient_group.ingredients
],
}
def to_model(self):
"""
Convert an ingredient group from the form data
to an ingredient group model
"""
ingredient_group = models.IngredientGroup()
ingredient_group.title = self.title.data
ingredient_group.ingredients = [i.to_model() for i in self.ingredients]
return ingredient_group
class BattleEditForm(asb.forms.CSRFTokenForm):
"""An admin-only form for editing a battle."""
title = wtforms.TextField('Title')
refs = wtforms.FieldList(
wtforms.FormField(BattleEditRefForm, [wtforms.validators.Optional()]),
)
save = wtforms.SubmitField('Save')
def set_refs(self, battle):
"""Set data for the ref table based on the battle's current refs."""
for ref in battle.all_refs:
print(self.refs.data)
self.refs.append_entry({
'ref': ref.trainer.name,
'current': ref.is_current_ref,
'emergency': ref.is_emergency_ref
})
# Also add one blank row
self.refs.append_entry()
def make_relation_field(model, *args, **kwargs):
class ItemWidget(unicode):
def all_objects(self):
return model.query.all()
def object_title(self, obj):
object_title_attr = kwargs.get('object_title_attr')
if object_title_attr:
return getattr(obj, object_title_attr)
else:
return getattr(obj, 'title', unicode(obj))
class RelationField(wtforms.IntegerField):
widget = wtforms.widgets.HiddenInput()
def process_formdata(self, valuelist):
[id] = valuelist
self.data = model.query.get(id)
return wtforms.FieldList(
RelationField(),
*args,
widget=ItemWidget('sapyens.crud:templates/relation.mako'))
class CreateModuleForm(FlaskForm):
builds = wtforms.FieldList(wtforms.StringField("Builds ID list"))
packages = wtforms.FieldList(wtforms.StringField("Packages list"))
filter = wtforms.FieldList(wtforms.StringField("Package Filter"))
api = wtforms.FieldList(wtforms.StringField("Module API"))
profile_names = wtforms.FieldList(wtforms.StringField("Install Profiles"),
min_entries=2)
profile_pkgs = wtforms.FieldList(wtforms.FieldList(
wtforms.StringField("Install Profiles")),
min_entries=2)
def __init__(self, copr=None, *args, **kwargs):
self.copr = copr
super(CreateModuleForm, self).__init__(*args, **kwargs)
def validate(self):
if not FlaskForm.validate(self):
return False
# Profile names should be unique
names = [x for x in self.profile_names.data if x]
if len(set(names)) < len(names):
self.errors["profiles"] = ["Profile names must be unique"]
return False
# WORKAROUND
# profile_pkgs are somehow sorted so if I fill profile_name in the first box and
# profile_pkgs in seconds box, it is sorted and validated correctly
for i in range(0, len(self.profile_names.data)):
# If profile name is not set, then there should not be any packages in this profile
if not flask.request.form["profile_names-{}".format(i)]:
if [
j for j in range(0, len(self.profile_names)) if
"profile_pkgs-{}-{}".format(i, j) in flask.request.form
]:
self.errors["profiles"] = ["Missing profile name"]
return False
return True
class AliquotCrudForm(wtforms.Form):
aliquot = wtforms.FieldList(wtforms.FormField(AliquotForm))
class SpecimenCrudForm(wtforms.Form):
specimen = wtforms.FieldList(wtforms.FormField(SpecimenAliquotForm))
class LinksListForm(Form):
links = wtforms.FieldList(wtforms.FormField(LinkForm), max_entries=5)
class Transfer(FlaskForm):
private_key = wtf.StringField('Private Key')
recipients = wtf.FieldList(wtf.FormField(Recipient), min_entries=1)
submit = wtf.SubmitField('Send')
class ModelForm(Form):
def __init__(self, csrf_enabled=False, *args, **kwargs):
super(ModelForm, self).__init__(csrf_enabled=csrf_enabled, *args, **kwargs)
### Methods
def required_if_method(value):
def _required(form, field):
if form.method.data == value:
if not field.data or (isinstance(field.data, str) and field.data.strip() == ""):
raise validators.ValidationError('This field is required.')
else:
field.errors[:] = []
raise validators.StopValidation()
return _required
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 = wtforms.SelectField('Select Dataset', choices=[])
train_epochs = wtforms.IntegerField('Training epochs',
validators = [
validators.NumberRange(min=1)
],
default=30,
)
val_interval = wtforms.IntegerField('Validation interval (in epochs)',
validators = [
validators.NumberRange(min=0)
],
default=1,
)
batch_size = wtforms.IntegerField('Batch size',
validators = [
validators.NumberRange(min=1),
validators.Optional(),
],
)
### Learning rate
learning_rate = wtforms.FloatField('Base Learning Rate',
default = 0.01,
validators = [
validators.DataRequired(),
validators.NumberRange(min=0),
]
)
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:
v = 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
method = wtforms.HiddenField('Model type',
validators = [
validators.AnyOf(
['standard', 'previous', 'custom'],
message='The method you chose is not currently supported.'
)
],
default = 'standard',
)
# The options for this get set in the view (since they are dependent on )
standard_networks = wtforms.RadioField('Standard Networks',
validators = [
required_if_method('standard'),
],
)
previous_networks = wtforms.RadioField('Previous Networks',
choices = [],
validators = [
required_if_method('previous'),
],
)
previous_network_snapshots = wtforms.FieldList(
wtforms.SelectField('Snapshots',
validators = [validators.Optional()]
),
)
custom_network = wtforms.TextAreaField('Custom Network',
validators = [
required_if_method('custom'),
validate_NetParameter,
]
)
custom_network_snapshot = wtforms.TextField('Pretrained model')
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')
model_name = wtforms.StringField('Model Name',
validators = [
validators.DataRequired()
]
)
class EditMetaDataForm(wtforms.Form):
media_metadata = wtforms.FieldList(wtforms.FormField(MetaDataForm, ""), )
class TargetForm(wtforms.Form):
"""A form for a player to choose night action targets."""
targets = wtforms.FieldList(wtforms.SelectField(choices=[], coerce=int))
submit = wtforms.SubmitField("Submit")
class CrudForm(wtforms.Form):
aliquot = wtforms.FieldList(wtforms.FormField(CheckoutForm))
class EpisodesImportForm(wtforms.Form):
""" This is used for adding episodes to the database """
media = wtforms.FieldList(wtforms.FormField(EpisodeForm))
class EpisodesSeasonForm(wtforms.Form):
""" This is used for adding episodes to seasons """
media = wtforms.FieldList(wtforms.FormField(SeasonEpisodeForm))
class EncounterStartForm(w.Form):
actors = f.FieldList(f.FormField(EncounterActorStartForm,""),"")
events = f.FieldList(f.FormField(EncounterEventStartForm,""),"")
start = f.SubmitField('Start encounter')
