text stringlengths 0 1.05M | meta dict |
|---|---|
from flask_wtf import Form
from wtforms import StringField, TextAreaField, BooleanField, SubmitField
from wtforms.fields.html5 import DateField
from wtforms.validators import Optional, Length, Required, URL, Email
from flask_pagedown.fields import PageDownField
class ProfileForm(Form):
name = StringField('Name', validators=[Optional(), Length(1, 64)])
location = StringField('Location', validators=[Optional(), Length(1, 64)])
bio = TextAreaField('Bio')
submit = SubmitField('Submit')
class TalkForm(Form):
title = StringField('Title', validators=[Required(), Length(1, 128)])
description = TextAreaField('Description')
slides = StringField('Slides Embed Code (450 pixels wide)')
video = StringField('Video Embed Code (450 pixels wide)')
venue = StringField('Venue',
validators=[Required(), Length(1, 128)])
venue_url = StringField('Venue URL',
validators=[Optional(), Length(1, 128), URL()])
date = DateField('Date')
submit = SubmitField('Submit')
def from_model(self, talk):
self.title.data = talk.title
self.description.data = talk.description
self.slides.data = talk.slides
self.video.data = talk.video
self.venue.data = talk.venue
self.venue_url.data = talk.venue_url
self.date.data = talk.date
def to_model(self, talk):
talk.title = self.title.data
talk.description = self.description.data
talk.slides = self.slides.data
talk.video = self.video.data
talk.venue = self.venue.data
talk.venue_url = self.venue_url.data
talk.date = self.date.data
class PresenterCommentForm(Form):
body = PageDownField('Comment', validators=[Required()])
submit = SubmitField('Submit')
class CommentForm(Form):
name = StringField('Name', validators=[Required(), Length(1, 64)])
email = StringField('Email', validators=[Required(), Length(1, 64),
Email()])
body = PageDownField('Comment', validators=[Required()])
notify = BooleanField('Notify when new comments are posted', default=True)
submit = SubmitField('Submit')
| {
"repo_name": "miguelgrinberg/flask-pycon2014",
"path": "app/talks/forms.py",
"copies": "1",
"size": "2209",
"license": "mit",
"hash": 4598122794950463500,
"line_mean": 37.7543859649,
"line_max": 78,
"alpha_frac": 0.6514259846,
"autogenerated": false,
"ratio": 4.105947955390334,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 57
} |
from flask_wtf import Form
from wtforms import StringField, TextAreaField, Field, ValidationError
from wtforms.widgets import TextArea
from wtforms.validators import DataRequired, Length
from flask_user import UserMixin
from yamlstore import db
from flask import json
import yaml
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
# User Authentication information
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, default='')
#reset_password_token = db.Column(db.String(100), nullable=False, default='')
# User Email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
# User information
is_enabled = db.Column(db.Boolean(), nullable=False, default=False)
#first_name = db.Column(db.String(50), nullable=False, default='')
#last_name = db.Column(db.String(50), nullable=False, default='')
yaml_documents = db.relationship(
'YamlDocument', backref='user', lazy='dynamic')
def is_active(self):
return self.is_enabled
class YamlDocument(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(99))
document = db.Column(db.String(9999))
json = db.Column(db.String(9999))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __init__(self, user_id):
self.user_id = user_id
class YamlDocumentField(TextAreaField):
def __init__(self, label='', validators=None, **kwargs):
super(TextAreaField, self).__init__(label, validators, **kwargs)
self.data=None
self.json_string=None
def process_formdata(self, valuelist):
if valuelist:
self.data = valuelist[0]
try:
data = yaml.safe_load(self.data)
json_string = json.htmlsafe_dumps(data, indent=' ')
except yaml.YAMLError as e: #to do: json error here
self.json_string = None
raise ValidationError(str(e))
else:
self.json_string = json_string
else:
self.data = None
self.json_string = None
class EditDocumentForm(Form):
title = StringField('title', validators=[
DataRequired(),
Length(max=99)])
document = YamlDocumentField('document', validators=[
Length(max=9999)]) | {
"repo_name": "ericstalbot/yamlstore",
"path": "yamlstore/models.py",
"copies": "1",
"size": "2526",
"license": "bsd-2-clause",
"hash": -1940745699878482400,
"line_mean": 30.9873417722,
"line_max": 81,
"alpha_frac": 0.6270783848,
"autogenerated": false,
"ratio": 3.874233128834356,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5001311513634356,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import StringField, TextAreaField, RadioField, BooleanField
from wtforms.validators import DataRequired
class PasteDataForm(Form):
data_type = RadioField(label='What would you like to convert to?',
description ='',
choices=[('csv', 'CSV'),('json','JSON')],
validators=[DataRequired(),])
data_blob = TextAreaField(label='Dump your data here',
validators=[DataRequired(),])
#csv related fields
header_row = BooleanField(label='Is first row the header row?',
default='y')
delimiters = RadioField(label='Field Separator',
choices=[(',', 'Comma [,]'),
(';', 'Semi-Colon [;]'),
(':', 'Colon [:]'),
('|', 'Bar [|]'),
(r'\t', 'Tab'),
(r'\s', 'Space')],
default=',',
validators=[DataRequired(),])
| {
"repo_name": "DeeKras/csv2json",
"path": "forms.py",
"copies": "1",
"size": "1157",
"license": "mit",
"hash": 3933199544091861500,
"line_mean": 43.5,
"line_max": 72,
"alpha_frac": 0.4278305964,
"autogenerated": false,
"ratio": 5.356481481481482,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6284312077881482,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import StringField, TextAreaField, SelectField, FieldList
from wtforms.ext.sqlalchemy.fields import QuerySelectField
from wtforms.validators import Length
from project.models import PageBlock
class PageBlockForm(Form):
block_type = SelectField(
label='Select layout',
choices=[
(PageBlock.TYPE.img_left.value, 'Layout with image left'),
(PageBlock.TYPE.img_right.value, 'Layout with image right'),
(PageBlock.TYPE.no_img.value, 'Layout with no image'),
],
coerce=lambda x: PageBlock.TYPE(int(x)),
default=PageBlock.TYPE.img_left,
)
title = StringField(
label='Title',
validators=[
Length(
max=128,
message='Must not exceed 128 symbols',
),
],
)
short_description = TextAreaField(
label='Short description (used to display pageblock in list)',
validators=[
Length(
max=256,
message='Must not exceed 256 symbols',
),
],
)
text = TextAreaField(
label='Text',
)
image = StringField(
label='Image (url for now)',
)
class PageForm(Form):
def __init__(self, *args, **kwargs):
super(PageForm, self).__init__(*args, **kwargs)
pageblocks = PageBlock.query.all()
for block in self.blocks:
block.query = pageblocks
title = StringField(
label='Title',
validators=[
Length(
max=128,
message='Must not exceed 128 symbols',
),
],
)
blocks = FieldList(
QuerySelectField(),
min_entries=1,
)
| {
"repo_name": "saklar13/Meowth",
"path": "project/pages/forms.py",
"copies": "1",
"size": "1762",
"license": "bsd-3-clause",
"hash": -3990232982697072600,
"line_mean": 26.53125,
"line_max": 72,
"alpha_frac": 0.5550510783,
"autogenerated": false,
"ratio": 4.394014962593516,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5449066040893517,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import StringField, TextAreaField, SelectField
from wtforms.validators import DataRequired
from user_defined_functions import UserDefinedFunctions
import inspect
class UserFunctionForm(Form):
name = StringField('Name', validators=[DataRequired()])
runnable = SelectField(u'Auto run', choices=[('yes', 'yes'), ('no', 'no')], default="no", validators=[DataRequired()])
params = TextAreaField('Params')
gspread_link = StringField('Google spreadsheet link', validators=[DataRequired()])
funcs = []
list_user_funcs = dir(UserDefinedFunctions)
user_funcs = [(uf,uf) for uf in list_user_funcs if "user_" in uf]
for func in user_funcs:
# get the args for this function:
args_list = inspect.getargspec(getattr(UserDefinedFunctions, func[0]))[0]
# args_list.remove('cls') # as 'cls', class, isn't really an arg for class methods
select_option = "%s(%s)" % (func[0], ', '.join(args_list))
aselect = (select_option, select_option)
funcs.append(aselect)
function = SelectField(u'Auto run', choices=funcs, validators=[DataRequired()])
| {
"repo_name": "KirillShaman/escalate_gspread",
"path": "app/functions/forms.py",
"copies": "1",
"size": "1106",
"license": "mit",
"hash": -5261622891216965000,
"line_mean": 45.0833333333,
"line_max": 120,
"alpha_frac": 0.7142857143,
"autogenerated": false,
"ratio": 3.7114093959731544,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4925695110273154,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import StringField, TextAreaField, SubmitField, BooleanField, SelectField, ValidationError
from wtforms.validators import DataRequired, Length, Email, Regexp
from ..models import Role, User
from flask_pagedown.fields import PageDownField
class NameForm(Form):
name = StringField('What is your name?', validators=[DataRequired()])
submit = SubmitField('Submit')
class EditProfileForm(Form):
name = StringField('Real name', validators=[Length(0, 64)])
location = StringField('Location', validators=[Length(0, 64)])
about_me = TextAreaField('About me')
submit = SubmitField('Submit')
# 管理员编辑个人资料
class EditProfileAdminForm(Form):
email = StringField('Email', validators=[DataRequired(), Length(1, 64), Email()])
username = StringField('Username', validators=[DataRequired(), Length(1, 64),
Regexp('^[A-Za-z][A-Za-z0-9_.]*$', 0,
'Username must have only letters,'
'numbers,dots or underscores')])
confirmed = BooleanField('Confirmed')
role = SelectField('Role', coerce=int) # 下拉列表，coerce=int 用于将默认的string转换为int，因为roleid是int
name = StringField('Real name', validators=[Length(0, 64)])
location = StringField('Location', validators=[Length(0, 64)])
about_me = TextAreaField('About me')
submit = SubmitField('Submit')
def __init__(self, user, *args, **kwargs):
super(EditProfileAdminForm, self).__init__(*args, **kwargs)
# SelectField 实例必须在其 choices 属性中设置各选项。选项必须是一个由元组组成的列表，
# 各元组都包含两个元素：选项的标识符和显示在控件中的文本字符串
self.role.choices = [(role.id, role.name)
for role in Role.query.order_by(Role.name).all()]
self.user = user
def vaildate_email(self, field):
if field.data != self.user.email and \
User.query.filter_by(email=field.data).first():
raise ValidationError('Email already registered')
def validate_username(self, field):
if User.query.filter_by(username=field.data).first():
raise ValidationError('Username already in use.')
class PostForm(Form):
# PageDownField Markdown 富文本编辑器
body = PageDownField("What's on your mind?", validators=[DataRequired()])
submit = SubmitField('Submit')
class CommentForm(Form):
body = StringField('Enter your comment', validators=[DataRequired()])
submit = SubmitField('Submit') | {
"repo_name": "thewangcj/MyFlasky",
"path": "app/main/forms.py",
"copies": "1",
"size": "2725",
"license": "mit",
"hash": 5142451670874599000,
"line_mean": 41.3,
"line_max": 103,
"alpha_frac": 0.6401261332,
"autogenerated": false,
"ratio": 3.563202247191011,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.47033283803910114,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import StringField, TextAreaField, SubmitField, SelectField
from wtforms.validators import DataRequired
import MyTrack
class SetupForm(Form): # only one field can have validators?
trainer = StringField('trainer')
caches = TextAreaField('caches', validators=[DataRequired()])
code = StringField('code')
class SetupChoiceForm(Form):
ce = SubmitField('Care Everywhere')
funds = SubmitField('AMB/IP Funds')
class CleanupForm(Form):
envs = [pairs for pairs in MyTrack.get_assigned("AMB_IP")]
caches = SelectField(choices=envs)
clean_one = SubmitField('Cleanup')
clean_all = SubmitField('Cleanup All')
class UtilityForm(Form):
stop_services = SubmitField('Stop Services')
restart_services = SubmitField('Restart Services')
overlord = SubmitField('Overlord')
class OverlordForm(Form):
tag = StringField('tag') # , validators=[DataRequired()])
opt_vars = StringField('opt_vars')
envs = TextAreaField('caches', validators=[DataRequired()])
# Pre-set tags
ce_diags = SubmitField("CE Diags")
ce_gateway_config = SubmitField("CE GatewayConfig")
# # # #
| {
"repo_name": "jabez007/Training_Helpyr",
"path": "WebApp/forms.py",
"copies": "1",
"size": "1168",
"license": "mit",
"hash": 4204109614080106500,
"line_mean": 27.487804878,
"line_max": 72,
"alpha_frac": 0.7071917808,
"autogenerated": false,
"ratio": 3.7435897435897436,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.49507815243897435,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import StringField, TextAreaField, SubmitField, TextField, \
PasswordField, BooleanField, SelectMultipleField, \
FormField, FieldList, SelectField
from wtforms.validators import DataRequired, Required, EqualTo, Email
class PostForm(Form):
""" Form for adding and editing a post. """
display_title = StringField(label="Post Title", description="Please enter a title.", validators=[DataRequired()])
categories = SelectMultipleField("Categories")
tags = SelectMultipleField("Tags")
content = TextAreaField(label="Post Text", description="Type post content here", validators=[DataRequired()])
publish_button = SubmitField(label="Publish")
save_as_draft_button = SubmitField(label="Save As Draft")
cancel = SubmitField(label='Cancel')
class DeleteConfirm(Form):
""" Short form to work as a confirm delete modal button. """
confirm_delete = SubmitField(label='Confirm Delete')
cancel = SubmitField(label='Cancel')
class LoginForm(Form):
""" Define the login form. """
login = TextField('User login', [Required(message='Forgot your login name?')])
password = PasswordField('Password', [Required(message='Must provide a password. ;-)')])
remember_me = BooleanField('remember_me', default=False)
class SignupForm(Form):
""" Define the form for registering a user."""
login = TextField('Login name', [Required()])
firstname = TextField('First Name', [Required()])
surname = TextField('Surname', [Required()])
email = TextField('Email Address', [Email(), Required()])
password = PasswordField('New Password', [Required(), EqualTo('confirm', message='Passwords must match')])
confirm = PasswordField('Repeat Password')
class AddCategoryForm(Form):
""" Define form for adding a category. """
add_category = TextField(label="Add a Category", description="Please enter a name for your category.", validators=[DataRequired()])
add_button = SubmitField(label="Add")
class AddTagForm(Form):
""" Define form for adding a category. """
add_tag = TextField(label="Add a Tag", description="Please enter a name for your tag.", validators=[DataRequired()])
add_button = SubmitField(label="Add")
class EditCategoryForm(Form):
""" Form for edit/merge/delete categories. """
categories = SelectField()
cat_edit_box = TextField(validators=[DataRequired()])
edit_button = SubmitField(label="Edit")
cancel_button = SubmitField(label='Cancel')
class MergeDeleteCategoryForm(Form):
""" Form to merge/delete categories. """
categories = SelectMultipleField()
merge_button = SubmitField(label="Merge")
delete_button = SubmitField(label="Delete")
cancel_button = SubmitField(label='Cancel')
class EditTagForm(Form):
""" Form for edit/merge/delete categories. """
tags = SelectField()
tag_edit_box = TextField(validators=[DataRequired()])
edit_button = SubmitField(label="Edit")
cancel_button = SubmitField(label='Cancel')
# Can probably merge tag and category forms
class MergeDeleteTagForm(Form):
""" Form to merge/delete tags. """
tags = SelectMultipleField()
merge_button = SubmitField(label="Merge")
delete_button = SubmitField(label="Delete")
cancel_button = SubmitField(label='Cancel') | {
"repo_name": "benhoyle/wordpress_converter",
"path": "wordpress_converter/forms.py",
"copies": "1",
"size": "3392",
"license": "mit",
"hash": 540345260030447600,
"line_mean": 42.5,
"line_max": 135,
"alpha_frac": 0.6875,
"autogenerated": false,
"ratio": 4.198019801980198,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5385519801980199,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import SubmitField, BooleanField, StringField, IntegerField, SelectField, TextAreaField
from wtforms.validators import DataRequired, Length, Regexp, NumberRange
from school.config import Config
from school.models import CourseType
class EditCourseForm(Form):
pass
class AddCourseForm(Form):
pass
class TeacherAddCourseForm(Form):
name = StringField("Name", validators=[
DataRequired(),
Length(min=Config.APP_COURSE_NAME_MIN, max=Config.APP_COURSE_NAME_MAX),
Regexp(r'^[a-zA-Z0-9 ]+$')])
degree_id = SelectField("Degree", coerce=int, validators=[DataRequired()], choices=[])
semester_id = SelectField("Semester", coerce=int, validators=[DataRequired()], choices=[])
submit = SubmitField("Add Optional Course")
class CDEditCourseForm(TeacherAddCourseForm):
type_id = SelectField("Type", coerce=int, validators=[DataRequired()],
choices=[(CourseType.OPTIONAL, "Optional"), (CourseType.OTHER_OPTIONAL, "Other Optional")])
package = SelectField("Package Nr", coerce=int, validators=[DataRequired()], choices=[(i, i) for i in range(1, 6)])
min_students = IntegerField("Min Students", validators=[DataRequired()])
max_students = IntegerField("Max Students", validators=[DataRequired()])
credits = IntegerField("Credits", validators=[DataRequired(),
NumberRange(min=0, max=Config.APP_COURSE_CREDITS * 2)])
approval_reason = TextAreaField("Reason")
is_approved = BooleanField("Approved")
submit = SubmitField("Edit Optional Course")
| {
"repo_name": "leyyin/university-SE",
"path": "school/course/forms.py",
"copies": "2",
"size": "1630",
"license": "mit",
"hash": 1959728090165516000,
"line_mean": 41.8947368421,
"line_max": 119,
"alpha_frac": 0.6920245399,
"autogenerated": false,
"ratio": 4.044665012406948,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5736689552306948,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import SubmitField, SelectField, DecimalField
from wtforms.validators import DataRequired, NumberRange
from school.user import User
from school.user.models import Role
class Statistic:
ORDERED_STUDENTS = 0
TEACHER_RANKING = 1
TEACHER_DISCIPLINES = 2
class SelectStatisticForm(Form):
selected_statistic = SelectField(label="Available statistics", coerce=int,
choices=[(Statistic.ORDERED_STUDENTS, "Students ordered by their professional results."),
(Statistic.TEACHER_RANKING, "Teacher with the best/worst results obtained."),
(Statistic.TEACHER_DISCIPLINES, "Disciplines given by a teacher")])
submit = SubmitField("Choose")
class OrderedStudentsStatisticFrom(Form):
presentation = "Ordered students"
from_each = SelectField(label="From each", coerce=int,
choices=[(0, "Group"), (1, "Year")])
order = SelectField(label="Order by", coerce=int,
choices=[(0, "Average mark (descending)"), (1, "Name (alphabetically)")])
message = "Value should be in the interval [%(min)s,%(max)s]."
average_mark_lower_bound = DecimalField(label="Lower bound",
default=1,
validators=[DataRequired(), NumberRange(min=1, max=10, message=message)])
average_mark_upper_bound = DecimalField(label="Upper bound", default=10)
show_statistic = SubmitField("Show")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
message = "Value should be in the interval [%(min)s,%(max)s]."
self.average_mark_upper_bound.validators = [DataRequired(), NumberRange(min=self.average_mark_lower_bound.data,
max=10,
message=message)]
class TeacherDisciplinesStatisticForm(Form):
presentation = "Disciplines given by a teacher"
teacher_name = SelectField(label="Teacher", coerce=int)
submit = SubmitField("Show")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.teacher_name.choices = [(t.id, t.realname) for t in
User.query.filter_by(role_id=Role.TEACHER).order_by('realname')]
# Teacher With Best Or Worst Results Obtained
class TeacherWBOWROStatisticForm(Form):
presentation = "Teacher with best or worst results obtained"
criteria = SelectField(label="Criteria", coerce=int,
choices=[(0, "Best results obtained"), (1, "Worst results obtained")])
submit = SubmitField("Show")
| {
"repo_name": "leyyin/university-SE",
"path": "school/statistics/forms.py",
"copies": "2",
"size": "2847",
"license": "mit",
"hash": -236768097586743740,
"line_mean": 44.9193548387,
"line_max": 126,
"alpha_frac": 0.5890410959,
"autogenerated": false,
"ratio": 4.138081395348837,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5727122491248837,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import SubmitField, SelectField, TextAreaField, BooleanField
from wtforms.validators import Required
class ReportForm(Form):
course = SelectField('Course', validators=[Required()],
choices=[('atoc185x', 'ATOC185x'),
('atoc185x_2', 'ATOC185x_2'), ('body101x', 'BODY101x'),
('body101x_2', 'BODY101x_2'), ('chem181x', 'CHEM181x'),
('chem181x_2', 'CHEM181x_2'), ('chem181x_3', 'CHEM181x_3'),
('groocx', 'GROOCX')])
anonymize = BooleanField('Anonymize')
submit = SubmitField('Submit')
class ProblemIdsReportForm(ReportForm):
problem_ids = TextAreaField('Problem Ids', validators=[Required()])
final_attempt = BooleanField('Final Attempt Only')
include_email = BooleanField('Include Email')
class BasicReportForm(ReportForm):
report = SelectField('Report', validators=[Required()],
choices=[('course_completers', 'Course Completers'),
('date_of_registration', 'Date of Registration'),
('forum', 'Forum'), ('ip_to_country', 'IP to Country'),
('sequential_aggregation', 'Sequential Aggregation'),
('user_info', 'User Info')])
class GeneralStatsForm(ReportForm):
pass
| {
"repo_name": "McGillX/edx_data_research",
"path": "edx_data_research/web_app/report/forms.py",
"copies": "1",
"size": "1425",
"license": "mit",
"hash": 5742263059110935000,
"line_mean": 42.1818181818,
"line_max": 89,
"alpha_frac": 0.5656140351,
"autogenerated": false,
"ratio": 4.253731343283582,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5319345378383582,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import SubmitField, TextAreaField, StringField, PasswordField, BooleanField
from wtforms.validators import InputRequired, Email
from PhoenixNow.model import db, User
class SignupForm(Form):
firstname = StringField("First Name", [InputRequired("Please Enter Your First Name")])
lastname = StringField("Last Name", [InputRequired("Please Enter Your Last Name")])
grade = StringField("Grade Level", [InputRequired("Please Enter Your Grade Level")])
email = StringField("Email", [InputRequired("Please Enter Your Email Address"), Email("This Field Requires a Valid Email Address")])
password = PasswordField('Password', [InputRequired("Please Enter a Password")])
confirmpassword = PasswordField('Confirm Password', [InputRequired("Please Repeat your Password")])
submit = SubmitField("Create account")
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
domain = self.email.data.lower().split('@')[1]
if domain != "guilford.edu":
self.email.errors.append("Must Register With Guilford.edu Email")
return False
user = User.query.filter_by(email = self.email.data.lower()).first()
if user:
self.email.errors.append("This Email Is Already Taken")
return False
if self.password.data == self.confirmpassword.data:
return True
else:
self.password.errors.append("Passwords Don't Match")
return False
class SigninForm(Form):
email = StringField("Email", [InputRequired("Please Enter Your Email Address"), Email("Please Enter Your Email Address")])
password = PasswordField('Password', [InputRequired("Please Enter a Password.")])
submit = SubmitField("Sign In")
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(email = self.email.data.lower()).first()
if user and user.check_password(self.password.data):
return True
else:
self.email.errors.append("Invalid E-mail or Password")
return False
class ResetForm(Form):
password = PasswordField('Password', [InputRequired("Please Enter a Password.")])
confirmpassword = PasswordField('Confirm Password', [InputRequired("Please Enter a Password.")])
submit = SubmitField("Sign In")
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
if self.password.data == self.confirmpassword.data:
return True
else:
self.password.errors.append("Passwords Don't Match")
return False
class RequestResetForm(Form):
email = StringField("Email", [InputRequired("Please Enter Your Email Address"), Email("Please Enter Your Email Address")])
submit = SubmitField("Submit")
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(email = self.email.data.lower()).first()
if user:
return True
else:
self.email.errors.append("This Email Does Not Exist")
return False
class ContactForm(Form):
name = StringField("Name", [InputRequired("Please Enter Your Name")])
email = StringField("Your Email", [InputRequired("Please Enter Your Email Address."), Email("This Field Requires a Valid Email Address")])
subject = StringField("Subject", [InputRequired("Please Enter a Subject")])
message = TextAreaField("Message", [InputRequired("Please Enter a Message")])
submit = SubmitField("Send")
class CheckinForm(Form):
checkin = SubmitField("Check-in Today")
class ScheduleForm(Form):
monday = BooleanField("Monday")
tuesday = BooleanField("Tuesday")
wednesday = BooleanField("Wednesday")
thursday = BooleanField("Thursday")
friday = BooleanField("Friday")
submit = SubmitField("Update")
class CalendarForm(Form):
date = StringField("Date")
submit = SubmitField("Go")
class EmailReminderForm(Form):
enabled = BooleanField("Enabled")
date = StringField("Reminder Time")
submit = SubmitField("Submit Time")
class UserForm(Form):
firstname = StringField("First Name")
lastname = StringField("Last Name")
grade = StringField("Grade Level")
submit = SubmitField("Edit Account")
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
| {
"repo_name": "ECGHelloWorld/PhoenixNow",
"path": "PhoenixNow/forms.py",
"copies": "1",
"size": "4615",
"license": "mit",
"hash": -7014690896249268000,
"line_mean": 34.2290076336,
"line_max": 141,
"alpha_frac": 0.688624052,
"autogenerated": false,
"ratio": 3.901098901098901,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5089722953098901,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextAreaField, StringField
from wtforms.validators import InputRequired
from app.views.cluster.models import Cluster
from app.views.template.models import VarParser, ObjectLoader
from app import db
from app.one import OneProxy
from app.one import INCLUDING_DONE
from jinja2 import Environment
import re
class ExpandException(Exception):
pass
class VirtualMachinePool(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
cluster_id = db.Column(db.Integer, nullable=False)
zone_number = db.Column(db.Integer, nullable=False)
template = db.Column(db.Text(), default='{% extends cluster.template %}')
vars = db.Column(db.Text(), default='')
cardinality = db.Column(db.Integer, nullable=False, default=1)
cluster = db.relationship(
'Cluster',
primaryjoin="and_(VirtualMachinePool.cluster_id == Cluster.id, VirtualMachinePool.zone_number == Cluster.zone_number)",
foreign_keys=[cluster_id, zone_number])
def __init__(self, id=None, name=None, zone_number=None, cluster_id=None, cardinality=None):
self.id = id
self.name = name
self.cluster_id = cluster_id
self.zone_number = zone_number
self.cardinality = cardinality
def __str__(self):
return 'VirtualMachinePool: id={}, name={}, cluster_id={}, cluster={}, ' \
'zone_number={}, template={}, vars={}, cardinality={}'.format(
self.id,
self.name,
self.cluster_id,
self.cluster,
self.zone_number,
self.template,
self.vars,
self.cardinality)
def __repr__(self):
self.__str__()
def get_memberships(self, fetch_vms=True):
"""
Get the PoolMembership objects that are associated with the pool
:param fetch_vms: If true, the vm attribute will be populated (incurs potentially
timely (1-2s) call to the ONE api
:return:
"""
memberships = PoolMembership.query.filter_by(pool=self).all()
if fetch_vms:
one_proxy = OneProxy(self.cluster.zone.xmlrpc_uri, self.cluster.zone.session_string, verify_certs=False)
vms_dict = {vm.id: vm for vm in one_proxy.get_vms(INCLUDING_DONE)}
for m in memberships:
m.vm = vms_dict[m.vm_id]
return memberships
def name_for_number(self, number):
pattern = re.compile("^([^\.]+)\.(.*)$")
match = pattern.match(self.name)
if match is None:
raise Exception("Failed to parse pool name for hostname of number: {}".format(number))
return '{}{}.{}'.format(match.group(1), number, match.group(2))
def num_legacy_vms(self, members):
num = 0
for m in members:
if m.is_legacy():
num += 1
return num
def num_done_vms(self, members):
num = 0
for m in members:
if m.is_done():
num += 1
return num
def get_cluster(self):
return Cluster.query.filter_by(zone_number=self.zone_number, id=self.cluster_id).first()
def get_members_to_shrink(self, members, confirm_vm_ids=None):
if len(members) <= self.cardinality:
return None
shrink = []
num_2_member = {m.parse_number(): m for m in members}
sorted_numbers = sorted(num_2_member)
while len(sorted_numbers) > self.cardinality:
candidate = num_2_member[sorted_numbers.pop()]
print('confirm list: {}'.format(confirm_vm_ids))
if confirm_vm_ids is not None and candidate.vm.id not in confirm_vm_ids:
raise Exception("member (name={}, vm_id={}) not in confirm list".format(
candidate.vm.name, candidate.vm.id))
shrink.append(candidate)
return shrink
def get_expansion_names(self, members, form_expansion_names):
"""
Checks if there are hosts that are required for expansion and if so generates their new
names by creating lowest missing values of 'N' in poolname<N>.sub.domain.tld.
:return:
expansion_names: array of new hostnames that need to be instantiated
"""
if (len(members) >= self.cardinality):
return None
members_by_num = {m.parse_number(): m for m in members}
expansion_names = []
for number in range(1, self.cardinality + 1):
if number not in members_by_num.keys():
expansion_name = self.name_for_number(number)
if form_expansion_names is not None and expansion_name not in form_expansion_names:
raise Exception("Hostname for expansion not previously confirmed in form submission, "
"review and confirm again: {}".format(expansion_name))
expansion_names.append(expansion_name)
if form_expansion_names is not None:
for form_name in form_expansion_names:
if form_name not in expansion_names:
raise Exception("Previously confirmed hostname for expansion no longer determined required, "
"review and confirm again: {}".format(form_name))
return expansion_names
@staticmethod
def get_all(cluster):
return db.session.query(VirtualMachinePool).filter_by(cluster=cluster)
def get_peer_pools(self):
return db.session.query(VirtualMachinePool).filter_by(cluster=self.cluster)
class PoolMembership(db.Model):
vm_id = db.Column(db.Integer, primary_key=True)
pool_id = db.Column(db.Integer, db.ForeignKey('virtual_machine_pool.id'), primary_key=True)
pool = db.relationship('VirtualMachinePool', backref=db.backref('virtual_machine_pool', lazy='dynamic'))
date_added = db.Column(db.DateTime, nullable=False)
template = db.Column(db.Text(), default='{% extends cluster.template %}')
def __init__(self, pool_id=None, pool=None, vm_id=None, date_added=None, vm=None, template=None):
self.pool_id = pool_id
self.pool = pool
self.vm_id = vm_id
self.date_added = date_added
self.vm = vm
self.template = template
def remove_cmd(self):
if self.is_done():
return 'delete'
else:
return "shutdown"
def is_legacy(self):
if self.template is None or self.template == '':
return True
def is_done(self):
if self.vm.state_id >= 4:
return True
def is_current(self):
env = Environment(loader=ObjectLoader())
vars = VarParser.parse_kv_strings_to_dict(
self.pool.cluster.zone.vars,
self.pool.cluster.vars,
self.pool.vars,
'hostname={}'.format(self.vm.name))
return self.template == env.from_string(self.pool.template).render(pool=self.pool, vars=vars)
@staticmethod
def get_all(zone):
return db.session.query(PoolMembership).join(
PoolMembership.pool, aliased=True).filter_by(zone=zone)
def parse_number(self):
if self.vm is None:
raise Exception("cannot determine number from virtual machine name when vm is None")
num_pattern = re.compile("^[\dA-Za-z]+\D(\d+)\.")
match = num_pattern.match(self.vm.name)
if match is not None:
return int(match.group(1))
else:
raise Exception("cannot determine number from virtual machine name {}".format(self.vm.name))
def __str__(self):
return 'PoolMembership: pool_id={}, pool={}, vm_id={}, vm={}, date_added={}'.format(
self.pool_id,
self.pool,
self.vm_id,
self.vm,
self.date_added)
def __repr__(self):
self.__str__()
class PoolEditForm(Form):
name = StringField('Name', [InputRequired()])
cardinality = StringField('Cardinality', [InputRequired()])
template = TextAreaField('Zone Template')
vars = TextAreaField('Zone Variables')
class GenerateTemplateForm(Form):
pass
| {
"repo_name": "blackberry/lifeguard",
"path": "app/views/vpool/models.py",
"copies": "1",
"size": "7477",
"license": "apache-2.0",
"hash": 6020465274973454000,
"line_mean": 34.2688679245,
"line_max": 123,
"alpha_frac": 0.6675137087,
"autogenerated": false,
"ratio": 3.658023483365949,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4825537192065949,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, DateField, BooleanField, HiddenField, validators, PasswordField, SelectField
class SignupForm(Form):
email = TextField('email', validators=[validators.Required(), validators.Email()])
fullname = TextField('fullname', validators=[validators.Required(),
validators.Length(min=3, max=128,
message='Name field must be between 3 and 128 characters long.')])
password = PasswordField('password', validators=[validators.Required(),
validators.EqualTo('confirm',
message='Passwords must match')])
confirm = PasswordField('confirm', validators=[validators.Required()])
agree_mailer = BooleanField('agree_mailer')
class SigninForm(Form):
email = TextField('email', validators=[validators.Required(), validators.Email()])
password = PasswordField('password', validators=[validators.Required()])
class ChangePasswordForm(Form):
current_password = PasswordField('current_password', validators=[validators.Required()])
new_password = PasswordField('new_password', validators=[validators.Required()])
confirm = PasswordField('confirm', validators=[validators.Required(), validators.EqualTo(
'new_password', message='Passwords must match')])
class LoginForm(Form):
provider = HiddenField('provider', validators=[validators.Required()])
remember_me = BooleanField('remember_me', default=False)
class ForgotPasswordForm(Form):
email = TextField('email', validators=[validators.Required(), validators.Email()])
class ProfileForm(Form):
fullname = TextField('fullname', validators=[validators.Required(), validators.Length(min=3, max=128, message='Name field must be between 3 and 128 characters long.')])
email = TextField('email', validators=[validators.Required(), validators.Email()])
birthday = DateField('birthday', validators=[ validators.Required()],format='%d/%m/%Y', description='Date format: day/month/year')
country = TextField('country', validators=[validators.Required(), validators.Length(max=50, message='Country field must be 50 characters long.')])
state_province_region = TextField('state_province_region', validators=[validators.Required(), validators.Length( max=50, message='Format error.')])
city = TextField('city', validators=[validators.Required(), validators.Length(max=50, message='City field must be 50 characters long.')])
profile = SelectField('gender', choices=[('development_agents', 'Development Agents'),('entrepreneurs', 'Entrepreneurs'), ('students', 'Students and Professionals')])
occupation = TextField('occupation', validators=[validators.Required(), validators.Length(max=50, message='Occupation field must be 50 characters long.')])
institution = TextField('institution', validators=[validators.Optional(), validators.Length(max=50, message='Institution field must be 50 characters long.')])
agree_mailer = BooleanField('agree_mailer')
| {
"repo_name": "DataViva/dataviva-site",
"path": "dataviva/apps/user/forms.py",
"copies": "1",
"size": "3145",
"license": "mit",
"hash": -7261722385231955000,
"line_mean": 64.5208333333,
"line_max": 172,
"alpha_frac": 0.6909379968,
"autogenerated": false,
"ratio": 4.618208516886931,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.580914651368693,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import (TextField,
PasswordField,
TextAreaField,
RadioField,
FileField,
SelectField,
BooleanField,
HiddenField,
FormField,
FieldList,
IntegerField,
validators)
from bson.objectid import ObjectId
class SecretForm(Form):
access_key_id = TextField('Access Key ID',
validators = [validators.required()])
secret_access_key = TextField('Secret Access Key',
validators = [validators.required()])
# bucket_name = TextField('Bucket',
# validators = [validators.required()])
# next_backend_global_host = TextField('Next Backend Host',
# validators = [validators.required()])
class CreateAccountForm(Form):
new_email = TextField('Email', validators=[validators.required()])
new_password = PasswordField('Password', validators=[validators.required()])
confirm_password = PasswordField('Confirm Password', validators=[validators.required()])
class LoginForm(Form):
email = TextField('Email', validators=[validators.required()])
password = PasswordField('Password', validators=[validators.required()])
class NewExperimentForm(Form):
name = TextField('Experiment Name', validators=[validators.required()])
description = TextAreaField('Description', validators=[validators.required()], default='Sorry! No description')
instructions = TextAreaField('Instructions', validators=[validators.required()], default='Sorry! No instructions')
debrief = TextAreaField('Debrief', validators=[validators.required()], default='Sorry! No debrief')
# The coerce line coerces the object_id from the select form to an actual ObjectId
target_set = SelectField('Target Set',coerce=ObjectId)
query_tries = IntegerField('queries',validators=[validators.required()], default=100)
query_duration = IntegerField('duration (min)',validators=[validators.required()], default=60)
class NewProjectForm(Form):
name = TextField('Project Name', validators=[validators.required()])
description = TextAreaField('Description', validators=[validators.required()])
#users = TextAreaField(u'Add Users', validators=[validators.required()]) #need to write custom validator
# need to set up permissions for users eventually, also, need to figure out how to auto select users and submit a list
class ManageTargets(Form):
target_id = HiddenField('not_set', validators=[validators.required()])
target_type = SelectField('Target Type', coerce=int)
primary_description = TextAreaField('Primary Description', validators=[validators.required()])
alt_description = TextAreaField('Alternative Description', validators=[validators.required()])
class TargetSetForm(Form):
name= TextField(u'Target Set Name', validators=[validators.required()])
| {
"repo_name": "kgjamieson/NEXT-psych",
"path": "gui/base/forms.py",
"copies": "1",
"size": "3094",
"license": "apache-2.0",
"hash": 8188695781616920000,
"line_mean": 50.5666666667,
"line_max": 122,
"alpha_frac": 0.6593406593,
"autogenerated": false,
"ratio": 4.918918918918919,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.019887622310316228,
"num_lines": 60
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, BooleanField, DecimalField, IntegerField, TextAreaField
from wtforms.validators import DataRequired
from farmsList.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
class ContactLandOwnerForm(Form):
name = TextField('Name', validators=[DataRequired()])
email = TextField('Email', validators=[DataRequired()])
phone = TextField('Phone', validators=[DataRequired()])
experience = TextAreaField('Please describe your past experience farming:', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(ContactLandOwnerForm, self).__init__(*args, **kwargs)
def validate(self):
initial_validation = super(ContactLandOwnerForm, self).validate()
if not initial_validation:
return False
return True
class NewParcel1Form(Form):
address = TextField('Address', validators=[DataRequired()])
hasWater = BooleanField('The property has a water meter installed.')
water = TextField('Water Meter Size')
size = DecimalField('Size (in acres)', validators=[DataRequired()])
developmentPlan = TextField('Maximum Lease', validators=[DataRequired()])
monthlyCost = IntegerField('Monthly Cost to Lease', validators=[DataRequired()])
ownerName = TextField('Name', validators=[DataRequired()])
email = TextField('Contact E-mail', validators=[DataRequired()])
geometry = TextField('Geometry', validators=[DataRequired()])
center = TextField('Center', validators=[DataRequired()])
knownPriorUses = TextField('Known Prior Uses')
def __init__(self, *args, **kwargs):
super(NewParcel1Form, self).__init__(*args, **kwargs)
def validate(self):
initial_validation = super(NewParcel1Form, self).validate()
if not initial_validation:
return False
return True
| {
"repo_name": "codeforamerica/westsac-urban-land-locator",
"path": "farmsList/public/forms.py",
"copies": "1",
"size": "2765",
"license": "bsd-3-clause",
"hash": 9080578404102868000,
"line_mean": 39.0724637681,
"line_max": 108,
"alpha_frac": 0.6712477396,
"autogenerated": false,
"ratio": 4.368088467614534,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.002019525371990133,
"num_lines": 69
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, BooleanField
from wtforms.validators import DataRequired, Email, EqualTo, Length
from app.user.models import User
class UserForm(Form):
username = TextField('Username', validators=[DataRequired(), Length(min=2, max=20)])
email = TextField('Email', validators=[Email(), DataRequired(), Length(max=128)])
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
class RegisterUserForm(UserForm):
password = PasswordField(
'Password',
validators=[
DataRequired(),
EqualTo(
'confirm',
message='Passwords must match'
),
Length(min=6, max=20)
]
)
confirm = PasswordField('Confirm Password', validators=[DataRequired()])
accept_tos = BooleanField('I accept the TOS', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.user = None
def validate(self):
rv = Form.validate(self)
if not rv:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append('Username already registered')
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append('Email already registered')
return False
self.user = user
return True
class EditUserForm(UserForm):
is_admin = BooleanField('Admin')
active = BooleanField('Activated')
| {
"repo_name": "waxhax/waxhax",
"path": "app/user/forms.py",
"copies": "1",
"size": "1654",
"license": "mit",
"hash": 5020470397757756000,
"line_mean": 29.0727272727,
"line_max": 88,
"alpha_frac": 0.6094316808,
"autogenerated": false,
"ratio": 4.197969543147208,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0004157065824167993,
"num_lines": 55
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, BooleanField
from wtforms.validators import DataRequired
from dynamicforms.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
class DynoForm(Form):
username = TextField('Username')
password = PasswordField('Password')
def __init__(self, *args, **kwargs):
super(DynoForm, self).__init__(*args, **kwargs)
self.user = None
textField1 = TextField('textField1', validators=[DataRequired()])
textField2 = TextField('textField2', validators=[DataRequired()])
boolField2 = BooleanField()
class ContentTypeForm(Form):
field1 = TextField('field1')
field2 = TextField('field1')
field3 = TextField('field1')
| {
"repo_name": "ossifrage/dynamicforms",
"path": "dynamicforms/public/forms.py",
"copies": "1",
"size": "1609",
"license": "bsd-3-clause",
"hash": 4990560191598210000,
"line_mean": 31.8367346939,
"line_max": 77,
"alpha_frac": 0.655686762,
"autogenerated": false,
"ratio": 4.168393782383419,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5324080544383419,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, BooleanField, SubmitField
from wtforms.validators import DataRequired, Optional, URL, Length, EqualTo
from enma.user.models import User
from enma.public.domain import compose_username
class ReadonlyTextField(TextField):
def __call__(self, *args, **kwargs):
kwargs.setdefault('readonly', True)
return super(ReadonlyTextField, self).__call__(*args, **kwargs)
class LoginUserPasswordForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
remember_me = BooleanField('remember_me', default=False)
login = SubmitField('Login')
def __init__(self, *args, **kwargs):
super(LoginUserPasswordForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginUserPasswordForm, self).validate()
if not initial_validation:
return False
username = compose_username(self.username.data, None, 'local')
self.user = User.query.filter_by(username=username).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
return True
class RegisterUserPasswordForm(Form):
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
password = PasswordField('Password',
validators=[Optional(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password',
message='Passwords must match')])
register = SubmitField('Create Account', id='register')
def __init__(self, *args, **kwargs):
super(RegisterUserPasswordForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterUserPasswordForm, self).validate()
if not initial_validation:
self.username.errors.append("Initial fail")
return False
username = compose_username(self.username.data, None, 'local')
self.user = User.query.filter_by(username=username).first()
if self.user:
self.username.errors.append("Username already registered")
return False
return True
class RequestPasswordChangeForm(Form):
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
request = SubmitField('Request')
def __init__(self, *args, **kwargs):
super(RequestPasswordChangeForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RequestPasswordChangeForm, self).validate()
if not initial_validation:
return False
username = compose_username(self.username.data, None, 'local')
self.user = User.query.filter_by(username=username).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "pixmeter/enma",
"path": "enma/public/forms.py",
"copies": "1",
"size": "3565",
"license": "bsd-3-clause",
"hash": -254883707348054560,
"line_mean": 34.3069306931,
"line_max": 79,
"alpha_frac": 0.6367461431,
"autogenerated": false,
"ratio": 4.484276729559748,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5621022872659748,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, BooleanField, SubmitField, TextAreaField, \
SelectField, IntegerField
from wtforms.validators import DataRequired, Length, Email, EqualTo, Required
USER_ROLES = [('provider', 'PROVIDER'), ('advocate', 'ADVOCATE'), ('admin', 'ADMIN')]
class RegisterForm(Form):
"""
Creates a form that requires an email,
password, phone number, and checked boxes.
"""
email = TextField(
'Email Address',
validators=[DataRequired(), Email(message=None), Length(min=6, max=40)]
)
phone_number = TextField(
'Phone Number',
validators=[DataRequired(), Length(min=10)])
password = PasswordField(
'Password',
validators=[DataRequired(), Length(min=2, max=25)]
)
confirm = PasswordField(
'Confirm Password',
validators=[DataRequired(), EqualTo('password', message='Passwords muct match.')]
)
role = SelectField('User Role', choices=USER_ROLES)
clothes = BooleanField('Clothes')
shelter = BooleanField('Shelter')
food = BooleanField('Food')
other = BooleanField('Other')
class DeleteUserForm(Form):
id = IntegerField('id')
class LoginForm(Form):
email = TextField('Email', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
GENDERS = [('male', 'Male'), ('female', 'Female'), ('unspecified', 'Unspecified')]
class AlertForm(Form):
description = TextAreaField('Description', validators=[DataRequired()])
shelter = BooleanField('Shelter')
food = BooleanField('Food')
clothes = BooleanField('Clothes')
other = BooleanField('Other')
gender = SelectField('Gender', choices=GENDERS)
age = IntegerField('Age')
class ResponseForm(Form):
message = TextAreaField('Message', validators=[DataRequired()]) | {
"repo_name": "Hack4Eugene/Hack4Cause2016",
"path": "src/bobby-drop-tables/15thnight/app/forms.py",
"copies": "1",
"size": "1877",
"license": "mit",
"hash": -6127128644046367000,
"line_mean": 32.5357142857,
"line_max": 89,
"alpha_frac": 0.6675546084,
"autogenerated": false,
"ratio": 3.9350104821802936,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5102565090580293,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, BooleanField, SubmitField, validators
from models import DatosUsuarios
class MyForm(Form):
username = TextField("Username", [validators.Required("Please enter your username.")])
password = PasswordField("Password", [validators.Required("Please enter your password.")])
remember_me = BooleanField('remember_me', default = False)
submit = SubmitField("Sign In")
def validate(self):
datos = DatosUsuarios()
Usuarios = datos.usuarios()
Password = datos.password()
rv = Form.validate(self)
if not rv:
return False
if self.username.data in Usuarios:
num_usuario = Usuarios.index(self.username.data)
else:
self.username.errors.append('Nombre de usuario invalido')
return False
if self.password.data != Password[num_usuario]:
self.password.errors.append('Password Incorrecto')
return False
return True
SECRET_KEY = 'secret'
| {
"repo_name": "fnbellomo/boneApp",
"path": "wsgi/module_login/forms.py",
"copies": "1",
"size": "1095",
"license": "mit",
"hash": -3889202778089119000,
"line_mean": 28.5945945946,
"line_max": 94,
"alpha_frac": 0.6347031963,
"autogenerated": false,
"ratio": 4.116541353383458,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5251244549683458,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, DateField, TextAreaField, SelectField, BooleanField
from wtforms.validators import DataRequired, Email, EqualTo, Length, Optional
# from clubflask.user.models import Privacy
#from clubflask.user.models import User, Profile, Privacy
#from clubflask.database import db
class RegisterForm(Form):
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
email = TextField('Email',
validators=[DataRequired(), Email(), Length(min=6, max=40)])
firstname = TextField('First Name', validators=[DataRequired()])
lastname = TextField('Last Name', validators=[DataRequired()])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password', message='Passwords must match')])
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("Username already registered")
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append("Email already registered")
return False
self.user = user
return True
class ProfileForm(Form):
first_name = TextField('First Name', validators=[DataRequired()])
last_name = TextField('Last Name', validators=[DataRequired()])
callsign = TextField('Call Sign', validators=[Optional(), Length(min=3, max=8)])
mobilephone = TextField('Mobile Phone', validators=[Length(max=10)])
homephone = TextField('Home Phone', validators=[Length(max=10)])
address = TextField(u'Mailing Address', validators=[Optional(),
Length(max=200)])
city = TextField('City')
state = TextField('State')
zip = TextField('Zip Code', validators=[Optional(), Length(min=5, max=5)])
county = TextField('County')
# These choices should come from somewhere else - the db.
licenseclass = SelectField(u'License Class', choices=[('',''),
('Tech', 'Technician'), ('General', 'General'),
('Extra', 'Extra'), ('Novice', 'Novice'), ('Advanced', 'Advanced')], validators=[Optional()])
# These fields are in the privacy table. Let's pull in the current record
# to set defaults.
#privacyoptions = Privacy.query.filter_by(user_id=Form.user_id).first()
#print "prid: %s" % prid.id
addtomailinglist = BooleanField('Add to mailing list?', default=True)
sharewithclub = BooleanField('Share contact information with club?')
enrollinwpaares = BooleanField('Enroll in WPA Ares?')
def __init__(self, *args, **kwargs):
super(ProfileForm, self).__init__(*args, **kwargs)
# self.callsign = None
def validate(self):
initial_validation = super(ProfileForm, self).validate()
if not initial_validation:
return False
return True
| {
"repo_name": "ytjohn/clubflask",
"path": "clubflask/user/forms.py",
"copies": "1",
"size": "3387",
"license": "bsd-3-clause",
"hash": 889373711289477800,
"line_mean": 40.3170731707,
"line_max": 101,
"alpha_frac": 0.6377325066,
"autogenerated": false,
"ratio": 4.135531135531136,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.026166607604754626,
"num_lines": 82
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, FileField
from wtforms.validators import DataRequired, Email, EqualTo, Length
from .models import User
class RegisterForm(Form):
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
picture = FileField('Your photo')
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password', message='Passwords must match')])
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("Username already registered")
return False
return True
| {
"repo_name": "cekk/fantacalcio-react",
"path": "fantacalcio/user/forms.py",
"copies": "1",
"size": "1094",
"license": "bsd-3-clause",
"hash": 4576964671351833600,
"line_mean": 38.0714285714,
"line_max": 86,
"alpha_frac": 0.6352833638,
"autogenerated": false,
"ratio": 4.46530612244898,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5600589486248979,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, HiddenField, BooleanField
from wtforms import SubmitField
from wtforms.validators import DataRequired, Email, EqualTo, Length
from wtforms import ValidationError
from .models import User
from flask import flash
class EmailExists(object):
"""
WTF Validator that checks if an email address already exists.
via the exclude parameter a specific email addressed can be excluded
from the check (i.e. the current email address of a user)
"""
def __init__(self, exclude='', message='Email already registered'):
self._exclude=exclude
self._message = message
def __call__(self, form, field):
user = User.query.filter_by(email=field.data).first()
if user and user.email != self._exclude:
raise ValidationError(self._message)
class RegisterForm(Form):
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
email = TextField('Email',
validators=[DataRequired(), Email(), EmailExists(),
Length(min=6, max=40)])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password', message='Passwords must match')])
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("Username already registered")
return False
return True
class EditForm(Form):
username = HiddenField('Username', validators=[])
firstname = TextField('First Name', validators=[DataRequired(),
Length(min=2, max=40)])
lastname = TextField('Last Name', validators=[DataRequired(),
Length(min=2, max=40)])
email = TextField('Email', validators=[DataRequired(), Email(),
Length(min=6, max=40)])
apply = SubmitField('Apply')
def update_data(self, user=None):
if user:
self.username.data = user.username
self.firstname.data = user.first_name
self.lastname.data = user.last_name
self.email.data = user.email
def validate(self):
initial_validation = super(EditForm, self).validate()
if not initial_validation:
return False
return True
class DeleteForm(Form):
username = HiddenField('Username', validators=[])
safety_question = BooleanField('Do you really want to delete the user?',
default = False)
delete = SubmitField('Delete')
def __init__(self, user=None, *args, **kwargs):
super(DeleteForm, self).__init__(*args, **kwargs)
print user
if user:
self.username.data = user.username
def validate(self):
if self.safety_question.data == 0:
self.safety_question.errors = []
self.safety_question.errors.append(
"Please confirm by setting the checkmark")
return False
return True
class ChangePasswordForm(Form):
username = HiddenField('username',)
oldpassword = PasswordField('Old Password',
validators=[DataRequired(), Length(min=6, max=40)])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password',
message='Passwords must match')])
setpwd = SubmitField('Set Password')
def update_data(self, user):
self.username.data = user.username
def validate(self):
flash('validate chpwd called', 'info')
initial_validation = super(ChangePasswordForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("User does not exist")
return False
if not user.check_password(self.oldpassword.data):
self.email.errors.append("Old password is wrong")
return False
return True | {
"repo_name": "steffen-mehner/Tests",
"path": "enma/user/forms.py",
"copies": "1",
"size": "4648",
"license": "bsd-3-clause",
"hash": 4135672302063392300,
"line_mean": 37.106557377,
"line_max": 86,
"alpha_frac": 0.6037005164,
"autogenerated": false,
"ratio": 4.574803149606299,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.005310308989078374,
"num_lines": 122
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, HiddenField, BooleanField
from wtforms import SubmitField, SelectField
from wtforms.validators import DataRequired, Email, EqualTo, Length, Optional
from wtforms import ValidationError
from .models import User
from flask import flash
from enma.public.domain import compose_username
class ReadonlyTextField(TextField):
def __call__(self, *args, **kwargs):
kwargs.setdefault('readonly', True)
return super(ReadonlyTextField, self).__call__(*args, **kwargs)
class ReadonlyBooleanField(BooleanField):
def __call__(self, *args, **kwargs):
kwargs.setdefault('disabled', True)
return super(ReadonlyBooleanField, self).__call__(*args, **kwargs)
class EmailExists(object):
"""
WTF Validator that checks if an email address already exists.
via the exclude parameter a specific email addressed can be excluded
from the check (i.e. the current email address of a user)
"""
def __init__(self, exclude='', message='Email already registered'):
self._exclude=exclude
self._message = message
def __call__(self, form, field):
user = User.query.filter_by(email=field.data).first()
if user and user.email != self._exclude:
raise ValidationError(self._message)
class EditForm(Form):
username = HiddenField('Username', validators=[])
firstname = TextField('First Name', validators=[DataRequired(),
Length(min=2, max=40)])
lastname = TextField('Last Name', validators=[DataRequired(),
Length(min=2, max=40)])
email = TextField('Email', validators=[DataRequired(), Email(),
Length(min=6, max=40)])
apply = SubmitField('Apply')
def update_data(self, user=None):
if user:
self.username.data = user.username
self.firstname.data = user.first_name
self.lastname.data = user.last_name
self.email.data = user.email
class DeleteForm(Form):
username = HiddenField('Username', validators=[])
safety_question = BooleanField('Do you really want to delete the user?',
default = False)
delete = SubmitField('Delete')
def __init__(self, user=None, *args, **kwargs):
super(DeleteForm, self).__init__(*args, **kwargs)
if user:
self.username.data = user.username
def validate(self):
if self.safety_question.data == 0:
self.safety_question.errors = []
self.safety_question.errors.append(
"Please confirm by setting the checkmark")
return False
return True
class ChangePasswordForm(Form):
oldpassword = PasswordField('Old Password',
validators=[DataRequired(), Length(min=6, max=40)])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password',
message='Passwords must match')])
setpwd = SubmitField('Set Password')
def __init__(self, user=None, *args, **kwargs):
super(ChangePasswordForm, self).__init__(*args, **kwargs)
self.user = user
def validate(self):
initial_validation = super(ChangePasswordForm, self).validate()
if not initial_validation:
return False
if not self.user.check_password(self.oldpassword.data):
self.oldpassword.errors.append("Old password is wrong")
return False
return True
class UserAdminForm(Form):
username = ReadonlyTextField('Username')
email = ReadonlyTextField('Email')
last_seen = ReadonlyTextField('Last seen')
created_at = ReadonlyTextField('Created at')
auth_provider = ReadonlyTextField('Authentication Provider')
email_validated = ReadonlyBooleanField('Email validated')
active = BooleanField('Is user active')
role = SelectField(u'Role', choices=[])
apply = SubmitField('Apply')
def __init__(self, roles=['SiteAdmin'], *args, **kwargs):
super(UserAdminForm, self).__init__(*args, **kwargs)
self.role.choices = map(lambda x: (x, x), roles)
def update_data(self, user=None):
if user:
self.username.data = user.nickname
self.email.data = user.email
self.auth_provider.data = user.auth_provider
self.created_at.data = user.created_at
self.last_seen.data = user.last_seen
self.email_validated.data = user.email_validated
self.active.data = user.active
self.role.data = str(user.role)
class RestTokenForm(Form):
token = ReadonlyTextField('Access Token')
expiry = ReadonlyTextField('Token Expiry')
lifetime = SelectField('Token Lifetime', default='60',
choices=[('60', 'One Minute'),
('3600', 'One hour'),
('86400', 'One day'),
('2592000', '30 days')])
generate = SubmitField('Generate new Token')
def update_data(self, user):
pass
class SetPasswordForm(Form):
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password',
message='Passwords must match')])
setpwd = SubmitField('Set Password') | {
"repo_name": "pixmeter/enma",
"path": "enma/user/forms.py",
"copies": "1",
"size": "5662",
"license": "bsd-3-clause",
"hash": 3035768576066885600,
"line_mean": 36.5033112583,
"line_max": 77,
"alpha_frac": 0.6080890145,
"autogenerated": false,
"ratio": 4.4234375,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.55315265145,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, IntegerField, HiddenField
from wtforms.validators import DataRequired, Length, Email, URL
class RegisterForm(Form):
name = TextField(
'Tell us your name:',
validators=[DataRequired(message="Name is required"),
Length(min=3, message="Name must greater than 3 chars")]
)
email = TextField(
'Enter your E-mail:',
validators=[DataRequired("E-mail is required"), Email(message="Invalid E-mail address")]
)
password = PasswordField(
'Password:',
validators=[DataRequired("Password is required")]
)
country_code = TextField(
'Country Code:',
validators=[DataRequired("Country code is required"),
Length(min=1, max=4, message="Country code must be between 1 and 4 numbers")]
)
phone_number = IntegerField(
'Phone Number:',
validators=[DataRequired("Valid phone number is required")]
)
class LoginForm(Form):
email = TextField(
'E-mail:',
validators=[DataRequired("E-mail is required"), Email(message="Invalid E-mail address")]
)
password = PasswordField(
'Password:',
validators=[DataRequired("Password is required")]
)
class VacationPropertyForm(Form):
description = TextField(
'Description:',
validators=[DataRequired("Description is required")]
)
image_url = TextField(
'Image URL:',
validators=[DataRequired("Image Url required"), URL(message="Invalid Image Url")]
)
class ReservationForm(Form):
message = TextField(
'Message:',
validators=[DataRequired("Message is required")]
)
property_id = HiddenField()
class ReservationConfirmationForm(Form):
From = TextField('From:')
Body = TextField('Body')
| {
"repo_name": "TwilioDevEd/airtng-flask",
"path": "airtng_flask/forms.py",
"copies": "1",
"size": "1961",
"license": "mit",
"hash": -5497468289676500000,
"line_mean": 29.1692307692,
"line_max": 101,
"alpha_frac": 0.6068332483,
"autogenerated": false,
"ratio": 4.635933806146572,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5742767054446571,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms import validators
from .models import User
class LoginForm(Form):
username = TextField(u'Username', validators=[validators.required()])
password = PasswordField(u'Password', validators=[validators.optional()])
def validate(self):
check_validate = super(LoginForm, self).validate()
# if our validators do not pass
if not check_validate:
return False
# Does our the exist
user = User.query.filter_by(username=self.username.data).first()
if not user:
self.username.errors.append('Invalid username or password')
return False
# Do the passwords match
if not user.check_password(self.password.data):
self.username.errors.append('Invalid username or password')
return False
return True
class ResetForm(Form):
password = PasswordField(u'Password', validators=[validators.required()])
repassword = PasswordField(u'Retype Password', validators=[validators.required()])
class LostPasswordForm(Form):
email = TextField(u'E-mail', validators=[validators.Email()])
| {
"repo_name": "emrahayanoglu/Flask-Skeleton",
"path": "web/forms.py",
"copies": "1",
"size": "1202",
"license": "mit",
"hash": -3415367376414940700,
"line_mean": 31.4864864865,
"line_max": 86,
"alpha_frac": 0.6805324459,
"autogenerated": false,
"ratio": 4.451851851851852,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5632384297751851,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Email, EqualTo, Length, AnyOf
from .models import User
class RegisterForm(Form):
access_code = TextField('Access Code',
validators=[DataRequired(), AnyOf(['BaconAndWaffles'], message='You must have the correct Access Code')])
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
email = TextField('Email',
validators=[DataRequired(), Email(), Length(min=6, max=40)])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password', message='Passwords must match')])
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("Username already registered")
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append("Email already registered")
return False
self.user = user
return True
| {
"repo_name": "peterdemartini/KrakenMaster",
"path": "kraken/user/forms.py",
"copies": "1",
"size": "1533",
"license": "bsd-3-clause",
"hash": 101269413705002510,
"line_mean": 40.4324324324,
"line_max": 125,
"alpha_frac": 0.6210045662,
"autogenerated": false,
"ratio": 4.430635838150289,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5551640404350289,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Email, EqualTo, Length
from .models import Comment
class RegisterForm(Form):
# username = TextField('Username',
# validators=[DataRequired(), Length(min=3, max=25)])
# email = TextField('Email',
# validators=[DataRequired(), Email(), Length(min=6, max=40)])
# password = PasswordField('Password',
# validators=[DataRequired(), Length(min=6, max=40)])
# confirm = PasswordField('Verify password',
# [DataRequired(), EqualTo('password', message='Passwords must match')])
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
# initial_validation = super(RegisterForm, self).validate()
# if not initial_validation:
# return False
# user = User.query.filter_by(username=self.username.data).first()
# if user:
# self.username.errors.append("Username already registered")
# return False
# user = User.query.filter_by(email=self.email.data).first()
# if user:
# self.email.errors.append("Email already registered")
# return False
return True | {
"repo_name": "codeforseoul/seoul_serenity",
"path": "seoul_serenity/comment/forms.py",
"copies": "2",
"size": "1371",
"license": "bsd-3-clause",
"hash": -9058232402922576000,
"line_mean": 40.5757575758,
"line_max": 88,
"alpha_frac": 0.6046681255,
"autogenerated": false,
"ratio": 4.192660550458716,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0038183385519065206,
"num_lines": 33
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Email, EqualTo, Length
'''
from .models import User
class RegisterForm(Form):
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
email = TextField('Email',
validators=[DataRequired(), Email(), Length(min=6, max=40)])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password', message='Passwords must match')])
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("Username already registered")
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append("Email already registered")
return False
return True
''' | {
"repo_name": "codeforseoul/seoul_serenity",
"path": "seoul_serenity/api/forms.py",
"copies": "2",
"size": "1337",
"license": "bsd-3-clause",
"hash": 3329983945710373400,
"line_mean": 38.3529411765,
"line_max": 86,
"alpha_frac": 0.6178010471,
"autogenerated": false,
"ratio": 4.427152317880795,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6044953364980794,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Email, EqualTo, Length
from .models import User
class RegisterForm(Form):
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
email = TextField('Email',
validators=[DataRequired(), Email(), Length(min=6, max=40)])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password', message='Passwords must match')])
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("Username already registered")
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append("Email already registered")
return False
return True
| {
"repo_name": "ossifrage/cliffdivers",
"path": "cliffdivers/user/forms.py",
"copies": "33",
"size": "1331",
"license": "bsd-3-clause",
"hash": -8400165361386208000,
"line_mean": 39.3333333333,
"line_max": 86,
"alpha_frac": 0.6205860255,
"autogenerated": false,
"ratio": 4.4366666666666665,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0037527216645990595,
"num_lines": 33
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Email, EqualTo, Length
from .models import User
class RegisterForm(Form):
full_name = TextField(
'Full Name', validators=[DataRequired()]
)
email = TextField(
'Email',
validators=[DataRequired(), Email(), Length(min=6, max=40)]
)
password = PasswordField(
'Password',
validators=[DataRequired(), Length(min=6, max=40)]
)
confirm = PasswordField(
'Verify password',
[DataRequired(), EqualTo('password', message='Passwords must match')]
)
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append("Email already registered")
return False
return True
| {
"repo_name": "sharoonthomas/clearstate",
"path": "clearstate/user/forms.py",
"copies": "1",
"size": "1117",
"license": "bsd-3-clause",
"hash": -6512246944825763000,
"line_mean": 29.1891891892,
"line_max": 77,
"alpha_frac": 0.6222023277,
"autogenerated": false,
"ratio": 4.1835205992509366,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5305722926950937,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Email, EqualTo, Length
from .models import User
class RegisterForm(Form):
username = TextField('Username',
validators=[DataRequired(), Length(min=3, max=25)])
email = TextField('Email',
validators=[DataRequired(), Email(), Length(min=6, max=40)])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password', message='Passwords must match')])
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append("Username already registered")
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append("Email already registered")
return False
self.user = user
return True | {
"repo_name": "Nikola-K/fpage",
"path": "fpage/user/forms.py",
"copies": "1",
"size": "1373",
"license": "apache-2.0",
"hash": -9009815590864218000,
"line_mean": 37.1666666667,
"line_max": 98,
"alpha_frac": 0.6103423161,
"autogenerated": false,
"ratio": 4.501639344262295,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5611981660362295,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Email, EqualTo, Length
class ChangePasswordForm(Form):
oldpassword = PasswordField('Old Password',
validators=[DataRequired(), Length(min=6, max=40)])
password = PasswordField('Password',
validators=[DataRequired(), Length(min=6, max=40)])
confirm = PasswordField('Verify password',
[DataRequired(), EqualTo('password',
message='Passwords must match')])
def __init__(self, user=None, *args, **kwargs):
super(ChangePasswordForm, self).__init__(*args, **kwargs)
self.user = user
def validate(self):
initial_validation = super(ChangePasswordForm, self).validate()
if not initial_validation:
return False
if not self.user.check_password(self.oldpassword.data):
self.oldpassword.errors.append("Old password is wrong")
return False
return True
| {
"repo_name": "pixmeter/emba",
"path": "emba/restricted/forms.py",
"copies": "1",
"size": "1069",
"license": "bsd-3-clause",
"hash": -3374926833432272000,
"line_mean": 40.1153846154,
"line_max": 75,
"alpha_frac": 0.6192703461,
"autogenerated": false,
"ratio": 4.627705627705628,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5746975973805628,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Email, Length, EqualTo
from project.models import User
class LoginForm(Form):
email = TextField('email', validators=[DataRequired(), Email()])
password = PasswordField('password', validators=[DataRequired()])
class RegisterForm(Form):
email = TextField(
'email',
validators=[DataRequired(), Email(message=None), Length(min=6, max=40)])
password = PasswordField(
'password',
validators=[DataRequired(), Length(min=6, max=25)]
)
confirm = PasswordField(
'Repeat password',
validators=[
DataRequired(),
EqualTo('password', message='Passwords must match.')
]
)
def validate(self):
initial_validation = super(RegisterForm, self).validate()
if not initial_validation:
return False
user = User.query.filter_by(email=self.email.data).first()
if user:
self.email.errors.append("Email already registered")
return False
return True
class ResetPasswordForm(Form):
email = TextField(
'email', validators=[DataRequired(), Email(message=None), Length(min=6, max=40)])
class ChangePasswordForm(Form):
password = PasswordField(
'password',
validators=[DataRequired(), Length(min=6, max=25)]
)
confirm = PasswordField(
'Repeat password',
validators=[
DataRequired(),
EqualTo('password', message='Passwords must match.')
]
)
| {
"repo_name": "dylanshine/streamschool",
"path": "project/user/forms.py",
"copies": "1",
"size": "1613",
"license": "mit",
"hash": 5800640402220473000,
"line_mean": 27.8035714286,
"line_max": 89,
"alpha_frac": 0.6261624303,
"autogenerated": false,
"ratio": 4.359459459459459,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5485621889759459,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, EqualTo, Length
# Set your classes here.
class RegisterForm(Form):
name = TextField(
'Username', validators=[DataRequired(), Length(min=6, max=25)]
)
email = TextField(
'Email', validators=[DataRequired(), Length(min=6, max=40)]
)
password = PasswordField(
'Password', validators=[DataRequired(), Length(min=6, max=40)]
)
confirm = PasswordField(
'Repeat Password',
[DataRequired(),
EqualTo('password', message='Passwords must match')]
)
class OrderForm(Form):
order_id = TextField(
'Order Id', validators=[DataRequired(), Length(min=1, max=32)]
)
order_status = TextField(
'Order Status', validators=[DataRequired(), Length(min=6, max=40)]
)
product_name = TextField(
'Product Name', validators=[DataRequired(), Length(min=6, max=400)]
)
product_url = TextField(
'URL', validators=[DataRequired(), Length(min=10, max=400)]
)
cost_price = TextField(
'Price', validators=[DataRequired(), Length(min=1, max=6)]
)
class LoginForm(Form):
name = TextField('Username', [DataRequired()])
password = PasswordField('Password', [DataRequired()])
class ForgotForm(Form):
email = TextField(
'Email', validators=[DataRequired(), Length(min=6, max=40)]
)
| {
"repo_name": "apoorvrajsaxena/FlaskScrapy",
"path": "dist/forms.py",
"copies": "1",
"size": "1477",
"license": "mit",
"hash": -2824201628045210600,
"line_mean": 26.3518518519,
"line_max": 79,
"alpha_frac": 0.6228842248,
"autogenerated": false,
"ratio": 3.796915167095116,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9908082876139636,
"avg_score": 0.002343303151095976,
"num_lines": 54
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired, Length, Email, EqualTo
from app.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
class RegisterForm(Form):
firstname = TextField(
'username',
validators=[
DataRequired(),
Length(min=3, max=25)
]
)
lastname = TextField(
'username',
validators=[DataRequired(), Length(min=3, max=25)]
)
username = TextField(
'username',
validators=[DataRequired(), Length(min=3, max=25)]
)
email = TextField(
'email',
validators=[DataRequired(), Email(message=None), Length(max=255)]
)
password = PasswordField(
'password',
validators=[DataRequired(), Length(min=6,max=50)]
)
confirm = PasswordField(
'Repeat password',
validators = [
DataRequired(), EqualTo('password', message='Passwords must match.')
]
)
def validate(self):
rv = Form.validate(self)
result = True
if not rv:
result = False
user = User.query.filter_by(username=self.username.data).first()
if user is not None:
self.username.errors.append('Username is used!')
result = False
user = User.query.filter_by(email=self.email.data).first()
if user is not None:
self.email.errors.append('Email is used!')
result = False
return result
| {
"repo_name": "omarayad1/cantkeepup",
"path": "app/users/forms.py",
"copies": "1",
"size": "1404",
"license": "mit",
"hash": -4702970476953050000,
"line_mean": 23.2068965517,
"line_max": 71,
"alpha_frac": 0.7015669516,
"autogenerated": false,
"ratio": 3.25,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9077070879660143,
"avg_score": 0.07489921438797131,
"num_lines": 58
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from werkzeug import secure_filename
from fantacalcio.user.models import User
from flask_wtf.file import FileField
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
class PlayersForm(Form):
file = FileField('Players csv')
| {
"repo_name": "cekk/fantacalcio-react",
"path": "fantacalcio/public/forms.py",
"copies": "1",
"size": "1206",
"license": "bsd-3-clause",
"hash": -2639832884409914000,
"line_mean": 29.9230769231,
"line_max": 77,
"alpha_frac": 0.6650082919,
"autogenerated": false,
"ratio": 4.32258064516129,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0010256410256410256,
"num_lines": 39
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from alexistheman.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "gurkslask/alexistheman",
"path": "alexistheman/public/forms.py",
"copies": "1",
"size": "1069",
"license": "bsd-3-clause",
"hash": -5341624673288507000,
"line_mean": 32.40625,
"line_max": 77,
"alpha_frac": 0.6520112254,
"autogenerated": false,
"ratio": 4.381147540983607,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from autoposter.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append("Unknown username")
return False
if not self.user.check_password(self.password.data):
self.password.errors.append("Invalid password")
return False
if not self.user.active:
self.username.errors.append("User not activated")
return False
return True | {
"repo_name": "Widdershin/autoposter",
"path": "autoposter/public/forms.py",
"copies": "1",
"size": "1066",
"license": "bsd-3-clause",
"hash": 5436817468054771000,
"line_mean": 32.34375,
"line_max": 77,
"alpha_frac": 0.6519699812,
"autogenerated": false,
"ratio": 4.423236514522822,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5575206495722822,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from brewing.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "jorgeer/brewing",
"path": "brewing/public/forms.py",
"copies": "1",
"size": "1063",
"license": "bsd-3-clause",
"hash": -1315030791955229200,
"line_mean": 32.25,
"line_max": 77,
"alpha_frac": 0.6509877705,
"autogenerated": false,
"ratio": 4.410788381742739,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5561776152242739,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from chorizoweb.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "rtucker-mozilla/chorizoweb",
"path": "chorizoweb/public/forms.py",
"copies": "2",
"size": "1067",
"license": "mpl-2.0",
"hash": 6242684707185726000,
"line_mean": 32.34375,
"line_max": 77,
"alpha_frac": 0.6513589503,
"autogenerated": false,
"ratio": 4.390946502057613,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6042305452357613,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from clearstate.user.models import User
class LoginForm(Form):
email = TextField('Email', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(email=self.email.data).first()
if not self.user:
self.email.errors.append('Unknown email')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.email.errors.append('User not activated')
return False
return True
| {
"repo_name": "sharoonthomas/clearstate",
"path": "clearstate/public/forms.py",
"copies": "1",
"size": "1047",
"license": "bsd-3-clause",
"hash": -3170669654972574700,
"line_mean": 30.7272727273,
"line_max": 71,
"alpha_frac": 0.6437440306,
"autogenerated": false,
"ratio": 4.344398340248962,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5488142370848962,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from cliffdivers.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "ossifrage/cliffdivers",
"path": "cliffdivers/public/forms.py",
"copies": "1",
"size": "1068",
"license": "bsd-3-clause",
"hash": 1739195356069827800,
"line_mean": 32.375,
"line_max": 77,
"alpha_frac": 0.6516853933,
"autogenerated": false,
"ratio": 4.395061728395062,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5546747121695061,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from clubflask.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append("Unknown username")
return False
if not self.user.check_password(self.password.data):
self.password.errors.append("Invalid password")
return False
if not self.user.active:
self.username.errors.append("User not activated")
return False
return True | {
"repo_name": "ytjohn/clubflask",
"path": "clubflask/public/forms.py",
"copies": "1",
"size": "1070",
"license": "bsd-3-clause",
"hash": 218693616055684640,
"line_mean": 31.4545454545,
"line_max": 77,
"alpha_frac": 0.6485981308,
"autogenerated": false,
"ratio": 4.439834024896266,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.007655502392344498,
"num_lines": 33
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from cookie_flaskApp.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "sakhuja/cookie_lover",
"path": "cookie_flaskApp/public/forms.py",
"copies": "1",
"size": "1071",
"license": "bsd-3-clause",
"hash": -9113169931093954000,
"line_mean": 32.5,
"line_max": 77,
"alpha_frac": 0.6526610644,
"autogenerated": false,
"ratio": 4.425619834710743,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.003003432494279176,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from cwr_webclient.model.user import User
__author__ = 'Bernardo'
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "weso/CWR-WebClient",
"path": "cwr_webclient/utils/form.py",
"copies": "2",
"size": "1095",
"license": "mit",
"hash": 8081408436224196000,
"line_mean": 30.2857142857,
"line_max": 77,
"alpha_frac": 0.6484018265,
"autogenerated": false,
"ratio": 4.27734375,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 35
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from dash.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "kyukyukyu/dash",
"path": "dash/public/forms.py",
"copies": "1",
"size": "1062",
"license": "bsd-3-clause",
"hash": -6477607392999295000,
"line_mean": 31.1818181818,
"line_max": 77,
"alpha_frac": 0.6487758945,
"autogenerated": false,
"ratio": 4.425,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 33
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from dhmn_demo.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "christianmlong/dhmn",
"path": "dhmn_demo/public/forms.py",
"copies": "1",
"size": "1066",
"license": "bsd-3-clause",
"hash": -1932178790005364700,
"line_mean": 32.3125,
"line_max": 77,
"alpha_frac": 0.6500938086,
"autogenerated": false,
"ratio": 4.386831275720165,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from dragon_lite.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "Magellanea/Dragon-Lite",
"path": "dragon_lite/public/forms.py",
"copies": "1",
"size": "1068",
"license": "bsd-3-clause",
"hash": -4624561478580275000,
"line_mean": 32.375,
"line_max": 77,
"alpha_frac": 0.6507490637,
"autogenerated": false,
"ratio": 4.395061728395062,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5545810792095062,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from enma.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "steffen-mehner/Tests",
"path": "enma/public/forms.py",
"copies": "1",
"size": "1060",
"license": "bsd-3-clause",
"hash": -6795885756096093000,
"line_mean": 32.15625,
"line_max": 77,
"alpha_frac": 0.65,
"autogenerated": false,
"ratio": 4.416666666666667,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.003003432494279176,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from etapi.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "hypebeast/etapi",
"path": "etapi/public/forms.py",
"copies": "1",
"size": "1062",
"license": "bsd-3-clause",
"hash": 8376799490142864000,
"line_mean": 32.1875,
"line_max": 77,
"alpha_frac": 0.6497175141,
"autogenerated": false,
"ratio": 4.406639004149378,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from event_store_meta.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "cwilkes/event_store_meta",
"path": "event_store_meta/public/forms.py",
"copies": "1",
"size": "1073",
"license": "bsd-3-clause",
"hash": -4546774370514520600,
"line_mean": 32.53125,
"line_max": 77,
"alpha_frac": 0.651444548,
"autogenerated": false,
"ratio": 4.397540983606557,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5548985531606557,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from extractor_train.user.models import User
from extractor_train.dlannotations.models import Dlannotations
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "dlarochelle/extractor_train",
"path": "extractor_train/public/forms.py",
"copies": "1",
"size": "1135",
"license": "bsd-3-clause",
"hash": 4532170435945270000,
"line_mean": 33.3939393939,
"line_max": 77,
"alpha_frac": 0.6651982379,
"autogenerated": false,
"ratio": 4.43359375,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0013175230566534915,
"num_lines": 33
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from flaskapp.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "skipallmighty/flask-app",
"path": "flaskapp/public/forms.py",
"copies": "1",
"size": "1064",
"license": "bsd-3-clause",
"hash": -9025652629186925000,
"line_mean": 32.28125,
"line_max": 77,
"alpha_frac": 0.6513157895,
"autogenerated": false,
"ratio": 4.433333333333334,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5584649122833334,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from flaskdemo.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "dpmehta02/flaskdemo",
"path": "flaskdemo/public/forms.py",
"copies": "1",
"size": "1066",
"license": "bsd-3-clause",
"hash": 7745206701368138000,
"line_mean": 32.3125,
"line_max": 77,
"alpha_frac": 0.6510318949,
"autogenerated": false,
"ratio": 4.423236514522822,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5574268409422822,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from FlaskStarter.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "tinker20/flask-boilerplate",
"path": "FlaskStarter/public/forms.py",
"copies": "1",
"size": "1069",
"license": "bsd-3-clause",
"hash": 162134362313304350,
"line_mean": 32.40625,
"line_max": 77,
"alpha_frac": 0.6520112254,
"autogenerated": false,
"ratio": 4.417355371900826,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from foobar.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "HRF92/myflask",
"path": "foobar/public/forms.py",
"copies": "2",
"size": "1063",
"license": "bsd-3-clause",
"hash": 3972322266963725000,
"line_mean": 32.21875,
"line_max": 77,
"alpha_frac": 0.6500470367,
"autogenerated": false,
"ratio": 4.429166666666666,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from gamecology.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "karimtabet/gamecology",
"path": "gamecology/public/forms.py",
"copies": "1",
"size": "1066",
"license": "bsd-3-clause",
"hash": -3485532205849367600,
"line_mean": 32.34375,
"line_max": 77,
"alpha_frac": 0.6519699812,
"autogenerated": false,
"ratio": 4.423236514522822,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5575206495722822,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from ibolc.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "jschaf/ibolcdb",
"path": "ibolc/public/forms.py",
"copies": "2",
"size": "1063",
"license": "bsd-3-clause",
"hash": -8295101545477580000,
"line_mean": 31.2121212121,
"line_max": 77,
"alpha_frac": 0.6491063029,
"autogenerated": false,
"ratio": 4.392561983471074,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6041668286371074,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from ifasecure.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "bwghughes/ifasecure",
"path": "ifasecure/public/forms.py",
"copies": "1",
"size": "1065",
"license": "bsd-3-clause",
"hash": 1589360789093531400,
"line_mean": 32.3125,
"line_max": 77,
"alpha_frac": 0.6516431925,
"autogenerated": false,
"ratio": 4.400826446280992,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.003003432494279176,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from kraken.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append("Unknown username")
return False
if not self.user.check_password(self.password.data):
self.password.errors.append("Invalid password")
return False
if not self.user.active:
self.username.errors.append("User not activated")
return False
return True | {
"repo_name": "peterdemartini/KrakenMaster",
"path": "kraken/public/forms.py",
"copies": "1",
"size": "1062",
"license": "bsd-3-clause",
"hash": 3756980959609936400,
"line_mean": 32.21875,
"line_max": 77,
"alpha_frac": 0.6506591337,
"autogenerated": false,
"ratio": 4.406639004149378,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.003003432494279176,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from martbell.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "tinker20/tinnker-flask",
"path": "martbell/public/forms.py",
"copies": "1",
"size": "1065",
"license": "bsd-3-clause",
"hash": -2436467291340194000,
"line_mean": 32.28125,
"line_max": 77,
"alpha_frac": 0.6507042254,
"autogenerated": false,
"ratio": 4.400826446280992,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from metapp2.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "phamtrisi/metapp2",
"path": "metapp2/forms.py",
"copies": "1",
"size": "1064",
"license": "bsd-3-clause",
"hash": 9213740931939689000,
"line_mean": 32.25,
"line_max": 77,
"alpha_frac": 0.6503759398,
"autogenerated": false,
"ratio": 4.396694214876033,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5547070154676033,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from myflaskapp.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "ecnahc515/example_docker_flask",
"path": "myflaskapp/public/forms.py",
"copies": "2",
"size": "1066",
"license": "bsd-3-clause",
"hash": -3525156466747097600,
"line_mean": 32.34375,
"line_max": 77,
"alpha_frac": 0.6519699812,
"autogenerated": false,
"ratio": 4.423236514522822,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6075206495722822,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from myflaskcooktest.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "se000ra/myflaskcooktest",
"path": "myflaskcooktest/public/forms.py",
"copies": "1",
"size": "1071",
"license": "bsd-3-clause",
"hash": 5025838868775456000,
"line_mean": 32.5,
"line_max": 77,
"alpha_frac": 0.6535947712,
"autogenerated": false,
"ratio": 4.407407407407407,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.003003432494279176,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from NewsReader.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "jrotich/NewsReader",
"path": "NewsReader/public/forms.py",
"copies": "1",
"size": "1067",
"license": "bsd-3-clause",
"hash": -3025703379010029600,
"line_mean": 32.34375,
"line_max": 77,
"alpha_frac": 0.6513589503,
"autogenerated": false,
"ratio": 4.427385892116183,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5578744842416183,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from news_serve.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "csik/news_serve",
"path": "news_serve/public/forms.py",
"copies": "1",
"size": "1067",
"license": "bsd-3-clause",
"hash": -5211799954167224000,
"line_mean": 32.34375,
"line_max": 77,
"alpha_frac": 0.6504217432,
"autogenerated": false,
"ratio": 4.409090909090909,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from pergamena.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "cekk/pergamena",
"path": "pergamena/public/forms.py",
"copies": "1",
"size": "1066",
"license": "bsd-3-clause",
"hash": 6236900678673594000,
"line_mean": 32.3125,
"line_max": 77,
"alpha_frac": 0.6510318949,
"autogenerated": false,
"ratio": 4.404958677685951,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from phonedusk.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "kevana/phonedusk-server",
"path": "phonedusk/public/forms.py",
"copies": "1",
"size": "1066",
"license": "bsd-3-clause",
"hash": -5445044887228346000,
"line_mean": 32.3125,
"line_max": 77,
"alpha_frac": 0.6510318949,
"autogenerated": false,
"ratio": 4.386831275720165,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from placebo_gov.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "Zarkantho/placebo.gov",
"path": "placebo_gov/public/forms.py",
"copies": "1",
"size": "1068",
"license": "bsd-3-clause",
"hash": 4036531239151067000,
"line_mean": 32.375,
"line_max": 77,
"alpha_frac": 0.6507490637,
"autogenerated": false,
"ratio": 4.395061728395062,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from ptdeckbuilder.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "anonfunc/ptdeckbuilder",
"path": "ptdeckbuilder/public/forms.py",
"copies": "1",
"size": "1069",
"license": "bsd-3-clause",
"hash": -6980602424841995000,
"line_mean": 32.4375,
"line_max": 77,
"alpha_frac": 0.6529466791,
"autogenerated": false,
"ratio": 4.435684647302905,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.003003432494279176,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from pwnurl.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append("Unknown username")
return False
if not self.user.check_password(self.password.data):
self.password.errors.append("Invalid password")
return False
if not self.user.active:
self.username.errors.append("User not activated")
return False
return True
| {
"repo_name": "donovan-duplessis/pwnurl",
"path": "pwnurl/prints/public/forms.py",
"copies": "1",
"size": "1058",
"license": "mit",
"hash": -8933888803895910000,
"line_mean": 32.0625,
"line_max": 77,
"alpha_frac": 0.6493383743,
"autogenerated": false,
"ratio": 4.408333333333333,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from recordthedocs.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "evolvedlight/recordthedocs",
"path": "recordthedocs/public/forms.py",
"copies": "1",
"size": "1069",
"license": "bsd-3-clause",
"hash": 5577330249371774000,
"line_mean": 32.4375,
"line_max": 77,
"alpha_frac": 0.6529466791,
"autogenerated": false,
"ratio": 4.454166666666667,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.003003432494279176,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from rymate_blog.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "rymate1234/rymate-blog",
"path": "rymate_blog/public/forms.py",
"copies": "1",
"size": "1067",
"license": "bsd-3-clause",
"hash": 1952492342539797800,
"line_mean": 32.375,
"line_max": 77,
"alpha_frac": 0.6513589503,
"autogenerated": false,
"ratio": 4.390946502057613,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5542305452357612,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from snapface.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "krekle/snapface",
"path": "snapface/public/forms.py",
"copies": "1",
"size": "1065",
"license": "bsd-3-clause",
"hash": -4349052209009764400,
"line_mean": 32.28125,
"line_max": 77,
"alpha_frac": 0.6507042254,
"autogenerated": false,
"ratio": 4.419087136929461,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.556979136232946,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from statusmap.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "evolvedlight/statusmap",
"path": "statusmap/public/forms.py",
"copies": "1",
"size": "1066",
"license": "bsd-3-clause",
"hash": -2657626462337979000,
"line_mean": 32.3125,
"line_max": 77,
"alpha_frac": 0.6510318949,
"autogenerated": false,
"ratio": 4.423236514522822,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5574268409422822,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from tedx2.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "chudichudichudi/neuro-tedx-2",
"path": "tedx2/public/forms.py",
"copies": "1",
"size": "1062",
"license": "bsd-3-clause",
"hash": -6427051536134395000,
"line_mean": 32.1875,
"line_max": 77,
"alpha_frac": 0.6497175141,
"autogenerated": false,
"ratio": 4.37037037037037,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.552008788447037,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from translatorsdesk.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "ltrc/TranslatorsDesk",
"path": "translatorsdesk/public/forms.py",
"copies": "3",
"size": "1072",
"license": "bsd-3-clause",
"hash": -2604015833670835000,
"line_mean": 32.5,
"line_max": 77,
"alpha_frac": 0.6529850746,
"autogenerated": false,
"ratio": 4.429752066115703,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from useradvocacy.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "mozilla/user-advocacy",
"path": "flask/useradvocacy/public/forms.py",
"copies": "1",
"size": "1068",
"license": "mpl-2.0",
"hash": 4815638525095621000,
"line_mean": 32.40625,
"line_max": 77,
"alpha_frac": 0.6526217228,
"autogenerated": false,
"ratio": 4.413223140495868,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5565844863295868,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from vBurgundy.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True | {
"repo_name": "michaelrice/vBurgundy",
"path": "vBurgundy/public/forms.py",
"copies": "1",
"size": "1065",
"license": "apache-2.0",
"hash": 5458493786489900000,
"line_mean": 32.3125,
"line_max": 77,
"alpha_frac": 0.6516431925,
"autogenerated": false,
"ratio": 4.382716049382716,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.003003432494279176,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from websterton.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "RylanGotto/web-dash",
"path": "websterton/public/forms.py",
"copies": "1",
"size": "1067",
"license": "bsd-3-clause",
"hash": 5929492981126449000,
"line_mean": 32.34375,
"line_max": 77,
"alpha_frac": 0.6513589503,
"autogenerated": false,
"ratio": 4.390946502057613,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5542305452357612,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from wexplorer.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "codeforamerica/wexplorer",
"path": "wexplorer/shared/forms.py",
"copies": "2",
"size": "1066",
"license": "bsd-3-clause",
"hash": -180458662775067680,
"line_mean": 32.3125,
"line_max": 77,
"alpha_frac": 0.6510318949,
"autogenerated": false,
"ratio": 4.404958677685951,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.001358695652173913,
"num_lines": 32
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField
from wtforms.validators import DataRequired
from wordup.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
| {
"repo_name": "douglasgoodwin/wordup",
"path": "wordup/public/forms.py",
"copies": "1",
"size": "1063",
"license": "bsd-3-clause",
"hash": 7301855223481492000,
"line_mean": 32.21875,
"line_max": 77,
"alpha_frac": 0.6500470367,
"autogenerated": false,
"ratio": 4.410788381742739,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5560835418442739,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, StringField
from wtforms.validators import DataRequired, Length, ValidationError
import phonenumbers as pn
"""
validate_phone
--------------
Custom validator. Validates that a StringField
that represents a phone number is in the correct format
"""
def validate_phone(form, field):
try:
# parse field into PhoneNumber object
phone = pn.parse(field.data, None)
# if StringField is not in the correct format, raise validation error
if not pn.is_valid_number(phone) or not pn.is_possible_number(phone):
raise ValidationError('Field must be valid phone number')
except pn.phonenumberutil.NumberParseException:
raise ValidationError('Field must be valid phone number')
"""
RegisterForm
------------
Form for validating registration requests.
Has username, password, and phone number fields
for the new user
"""
class RegisterForm(Form):
username = TextField('username', [DataRequired(), Length(min=1, max=119)])
password = PasswordField('password', [DataRequired(), Length(min=1, max=119)])
phone = StringField('phone', [DataRequired(), validate_phone])
"""
LoginForm
---------
Form for validating login requests.
Has username and password fields for the
user that is attempting to login
"""
class LoginForm(Form):
username = TextField('username', [DataRequired(), Length(min=1, max=119)])
password = PasswordField('password', [DataRequired(), Length(min=1, max=119)]) | {
"repo_name": "SteerClearWM/Steer-Clear-Backend",
"path": "steerclear/login/forms.py",
"copies": "3",
"size": "1519",
"license": "mit",
"hash": -7686228492923146000,
"line_mean": 33.5454545455,
"line_max": 82,
"alpha_frac": 0.7169190257,
"autogenerated": false,
"ratio": 4.184573002754821,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.640149202845482,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, SubmitField, StringField
from wtforms.validators import DataRequired, Email, EqualTo, Length
from .models import User
from .managers import EveManager
from .eve_api_manager import EveApiManager
class UpdateKeyForm(Form):
api_id = StringField(label='Key ID', validators=[DataRequired(), Length(min=1, max=10)])
api_key = StringField(label='Verification Code', validators=[DataRequired(), Length(min=1, max=254)])
submit = SubmitField(label='Submit')
def validate(self):
initial_validation = super(UpdateKeyForm, self).validate()
if not initial_validation:
return False
if EveManager.check_if_api_key_pair_exist(self.api_id.data):
self.api_id.errors.append(u'API key already registered with this site')
return False
if not EveApiManager.check_api_is_type_account(self.api_id.data,
self.api_key.data):
self.api_id.errors.append(u'API key is not an account wide API. Select \"All\" as the character when creating the API key.')
return False
if not EveApiManager.check_api_is_full(self.api_id.data,
self.api_key.data):
self.api_id.errors.append(u'API key is not a full API key. Select all items in all categories when creating the key, or use the provided \"Create a full API key\" button to preselect the correct items.')
return False
if not EveApiManager.check_api_is_not_expire(self.api_id.data,
self.api_key.data):
self.api_id.errors.append(u'API key has an expiry date. Please select the "No Expiry" box when creating the API key.')
return False
return True
| {
"repo_name": "tyler274/Recruitment-App",
"path": "recruit_app/user/forms.py",
"copies": "1",
"size": "1875",
"license": "bsd-3-clause",
"hash": -7326022117671273000,
"line_mean": 47.0769230769,
"line_max": 215,
"alpha_frac": 0.6368,
"autogenerated": false,
"ratio": 4.0672451193058565,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5204045119305857,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, TextAreaField, BooleanField
from wtforms.validators import DataRequired
from app import models
#from flask.ext.pagedown.fields import PageDownField
from flask import flash
class LoginForm(Form):
username = TextField('Username', [DataRequired()])
password = PasswordField('Password', [DataRequired()])
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
self.user = None
def validate(self):
rv = Form.validate(self)
if not rv:
flash(u'Please fill in the both fields.', 'alert-danger')
return False
user = models.User.query.filter_by(
username=self.username.data).first()
if user is not None and user.verify_password(self.password.data):
self.user = user
return True
flash(u'You failed with credentials', 'alert-danger')
return False
class NewUserForm(Form):
username = TextField('Username', [DataRequired()])
password = PasswordField('Password', [DataRequired()])
password2 = PasswordField('Password', [DataRequired()])
admin = BooleanField('Admin User')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
rv = Form.validate(self)
if not rv:
flash(u'Please fill in all the fields.', 'alert-danger')
return False
if self.password.data != self.password2.data:
flash(u'Check the password fields', 'alert-danger')
return False
return True
class NewPostForm(Form):
title = TextField('Title', [DataRequired()])
body = TextAreaField('Text', [DataRequired()])
# body = PageDownField('Text', [DataRequired()])
description = TextAreaField('Description', [DataRequired()])
slug = TextField('URL Slug')
tags = TextField('Tags')
# thumbnail = TextField('Thumbnail URL')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
rv = Form.validate(self)
if not rv:
flash(u'Please fill in all the fields.', 'alert-danger')
return False
return True
| {
"repo_name": "bembu/tidy",
"path": "app/forms.py",
"copies": "1",
"size": "2272",
"license": "mit",
"hash": 5825062488618732000,
"line_mean": 28.5064935065,
"line_max": 73,
"alpha_frac": 0.619278169,
"autogenerated": false,
"ratio": 4.078994614003591,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0020984020081641084,
"num_lines": 77
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, TextAreaField, DateField
from wtforms.validators import DataRequired, ValidationError, EqualTo
from wtforms import validators
from app.models import User, is_phone_number_exists, is_user_registrated, is_login_exists
def is_ctn_exists(form, field):
if not is_phone_number_exists(field.data):
raise ValidationError('Unknown phone number')
def is_login_busy(form, field):
if is_login_exists(field.data):
raise ValidationError('Username already busy')
def is_user_exists(form, field):
if not is_user_registrated(field.data):
raise ValidationError('User is not registrated')
def is_user_not_exists(form, field):
if is_user_registrated(field.data):
raise ValidationError('User already exists')
def date_validator(form, field):
pass
class LoginForm(Form):
ctn1 = TextField('ctn1', validators=[DataRequired(), is_user_exists])
username = TextField('username', validators=[DataRequired()])
password = PasswordField('password', validators=[DataRequired()])
# remember_me = BooleanField('remember_me', default = False)
def validate(self):
rv = Form.validate(self)
if not rv:
return False
username = User.query.filter_by(username=self.username.data).first()
if not username:
self.username.errors.append('Unknown username')
return False
password = User.query.filter_by(password = self.password.data).first()
if not password:
self.password.errors.append('Invalid password')
return False
user = User.query.filter_by(username = self.username.data).filter_by(ctn = self.ctn1.data).first()
if not user:
self.password.errors.append('Invalid username or phone number')
return False
return True
class RegistrationForm(Form):
ctn1 = TextField('ctn1', validators = [DataRequired(), is_ctn_exists, is_user_not_exists])
username = TextField('username', validators = [DataRequired(), is_login_busy])
password = PasswordField('password', validators = [DataRequired(), EqualTo('confirm', message='Passwords must match')])
confirm = PasswordField('confirm', validators = [DataRequired()])
email = TextField('email')
class AskPhoneForm(Form):
ctn1 = TextField('ctn1', validators=[DataRequired(), is_ctn_exists, is_user_not_exists])
class EditProfile(Form):
ctn1 = TextField('ctn1', validators=[DataRequired(), is_ctn_exists])
year = TextField('year')
month = TextField('month')
day = TextField('day')
about_me = TextAreaField('about_me')
| {
"repo_name": "polosate/get_subscribes",
"path": "app/forms.py",
"copies": "1",
"size": "2685",
"license": "mit",
"hash": -4231599452504128500,
"line_mean": 32.9873417722,
"line_max": 123,
"alpha_frac": 0.6815642458,
"autogenerated": false,
"ratio": 3.8522238163558105,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.00309747797323042,
"num_lines": 79
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, TextAreaField, RadioField, FileField, SelectField, BooleanField, HiddenField, FormField, FieldList, IntegerField, validators
from bson.objectid import ObjectId
class CreateAccountForm(Form):
new_email = TextField('Email', validators=[validators.required()])
new_password = PasswordField('Password', validators=[validators.required()])
confirm_password = PasswordField('Confirm Password', validators=[validators.required()])
class LoginForm(Form):
email = TextField('Email', validators=[validators.required()])
password = PasswordField('Password', validators=[validators.required()])
class NewExperimentForm(Form):
name = TextField('Experiment Name', validators=[validators.required()])
description = TextAreaField('Description', validators=[validators.required()], default='Sorry! No description')
instructions = TextAreaField('Instructions', validators=[validators.required()], default='Sorry! No instructions')
debrief = TextAreaField('Debrief', validators=[validators.required()], default='Sorry! No debrief')
# The coerce line coerces the object_id from the select form to an actual ObjectId
target_set = SelectField('Target Set',coerce=ObjectId)
query_tries = IntegerField('queries',validators=[validators.required()], default=100)
query_duration = IntegerField('duration (min)',validators=[validators.required()], default=60)
class NewProjectForm(Form):
name = TextField('Project Name', validators=[validators.required()])
description = TextAreaField('Description', validators=[validators.required()])
#users = TextAreaField(u'Add Users', validators=[validators.required()]) #need to write custom validator
# need to set up permissions for users eventually, also, need to figure out how to auto select users and submit a list
class ManageTargets(Form):
target_id = HiddenField('not_set', validators=[validators.required()])
target_type = SelectField('Target Type', coerce=int)
primary_description = TextAreaField('Primary Description', validators=[validators.required()])
alt_description = TextAreaField('Alternative Description', validators=[validators.required()])
class TargetSetForm(Form):
name= TextField(u'Target Set Name', validators=[validators.required()])
| {
"repo_name": "lalitkumarj/NEXT-psych",
"path": "gui/base/forms.py",
"copies": "1",
"size": "2353",
"license": "apache-2.0",
"hash": 5280820889336329000,
"line_mean": 60.9210526316,
"line_max": 170,
"alpha_frac": 0.7518062048,
"autogenerated": false,
"ratio": 4.551257253384913,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.029802819663188172,
"num_lines": 38
} |
from flask_wtf import Form
from wtforms import TextField, PasswordField, TextAreaField, SelectField, HiddenField
from wtforms.validators import DataRequired, Length, Email, EqualTo
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
class RegisterForm(Form):
username = TextField(
'username',
validators=[DataRequired(), Length(min=3, max=25)]
)
email = TextField(
'email',
validators=[DataRequired(), Email(message=None), Length(min=6, max=40)]
)
password = PasswordField(
'password',
validators=[DataRequired(), Length(min=6, max=25)]
)
confirm = PasswordField(
'Repeat password',
validators=[
DataRequired(), EqualTo('password', message='Passwords must match.')
]
)
class SnippetForm(Form):
snippet_id = HiddenField('snippet_id')
title = TextField('Title', validators=[DataRequired()])
code = TextAreaField('Code', validators=[DataRequired()])
desc = TextAreaField('Description')
snippet_type = SelectField(
'Type',
choices=[
('apache', 'Apache'),
('bash', 'Bash'),
('c#', 'C#'),
('c++', 'C++'),
('cSS', 'CSS'),
('coffeeScript', 'CoffeeScript'),
('diff', 'Diff'),
('dockerfile', 'Dockerfile'),
('go', 'Go'),
('gradle', 'Gradle'),
('html', 'HTML, XML'),
('hTTP', 'HTTP'),
('ini', 'Ini'),
('jSON', 'JSON'),
('java', 'Java'),
('javaScript', 'JavaScript'),
('lua', 'Lua'),
('makefile', 'Makefile'),
('markdown', 'Markdown'),
('nginx', 'Nginx'),
('objective C', 'Objective C'),
('pHP', 'PHP'),
('perl', 'Perl'),
('python', 'Python'),
('ruby', 'Ruby'),
('sql', 'SQL'),
('stylus', 'Stylus'),
('swift', 'Swift'),
],
validators=[DataRequired()])
tags = TextField('Tags')
| {
"repo_name": "froi/morsel",
"path": "forms.py",
"copies": "1",
"size": "2186",
"license": "mit",
"hash": -4309221781335739400,
"line_mean": 30.2285714286,
"line_max": 85,
"alpha_frac": 0.5068618481,
"autogenerated": false,
"ratio": 4.155893536121673,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5162755384221673,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, SelectField, BooleanField
from wtforms.validators import DataRequired, Email, EqualTo, Length, AnyOf
from .models import AlarmSetting
class AllSettings(Form):
# Alarm Status Enabled or Disabled
alarm_status = SelectField('Alarm Status', default='1',choices=[('0','Disabled'), ('1', 'Enabled')], validators=[DataRequired()])
# Alarm Hours
alarm_hours = SelectField('Alarm Hours', default='06', choices=[],
validators=[DataRequired()])
# Alarm Minutes
alarm_minutes = SelectField('Alarm Minutes', default='00', choices=[],
validators=[DataRequired()])
# Snooze Minutes
snooze_minutes = SelectField('Snooze Minutes', default='10', choices=[],
validators=[DataRequired()])
alarm_text = TextField('Alarm Text', default='ALARM!',validators=[Length(min=1, max=6)])
def __init__(self, *args, **kwargs):
super(AllSettings, self).__init__(*args, **kwargs)
def validate(self):
initial_validation = super(AllSettings, self).validate()
if not initial_validation:
return False
return True
| {
"repo_name": "peterdemartini/KrakenMaster",
"path": "kraken/all_settings/forms.py",
"copies": "1",
"size": "1187",
"license": "bsd-3-clause",
"hash": -1277603303207693000,
"line_mean": 38.5666666667,
"line_max": 133,
"alpha_frac": 0.647851727,
"autogenerated": false,
"ratio": 4.13588850174216,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.528374022874216,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, SelectField, PasswordField
from wtforms.validators import DataRequired
from cheapr.user.models import User
class LoginForm(Form):
username = TextField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(LoginForm, self).__init__(*args, **kwargs)
self.user = None
def validate(self):
initial_validation = super(LoginForm, self).validate()
if not initial_validation:
return False
self.user = User.query.filter_by(username=self.username.data).first()
if not self.user:
self.username.errors.append('Unknown username')
return False
if not self.user.check_password(self.password.data):
self.password.errors.append('Invalid password')
return False
if not self.user.active:
self.username.errors.append('User not activated')
return False
return True
class SearchForm(Form):
searchterm = TextField('Search', validators=[DataRequired()])
searchtype = SelectField('Type',choices=[('books', 'Books'), ('mobiles', 'Mobiles'),('electronics','Electronics'),('kitchen','Kitchen Appliances'),('tv','LED-LCD TVs'),
('laptop','Laptops'),('computers','Computers')])
def __init__(self, *args, **kwargs):
super(SearchForm, self).__init__(*args, **kwargs) | {
"repo_name": "antani/cheapr",
"path": "cheapr/public/forms.py",
"copies": "1",
"size": "1517",
"license": "bsd-3-clause",
"hash": -7421986248682579000,
"line_mean": 36.0243902439,
"line_max": 172,
"alpha_frac": 0.6367831246,
"autogenerated": false,
"ratio": 4.213888888888889,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.005494386770788284,
"num_lines": 41
} |
from flask_wtf import Form
from wtforms import TextField, SelectField, SelectMultipleField
from wtforms.validators import DataRequired
from comport.department.models import Department
class NewDepartmentForm(Form):
department_name = TextField('Department Name', validators=[DataRequired()])
department_short_name = TextField('Department Short Name', validators=[DataRequired()])
def __init__(self, *args, **kwargs):
super(NewDepartmentForm, self).__init__(*args, **kwargs)
self.department = None
def validate(self):
initial_validation = super(NewDepartmentForm, self).validate()
if not initial_validation:
return False
self.department = Department.query.filter_by(name=self.department_name.data).first()
if self.department:
self.department_name.errors.append('The department name "{}" is already registered.'.format(self.department_name.data))
return False
self.department = Department.query.filter_by(short_name=self.department_short_name.data).first()
if self.department:
self.department_short_name.errors.append('The department short name "{}" is already registered.'.format(self.department_short_name.data))
return False
return True
class EditUserForm(Form):
departments = SelectMultipleField("Departments")
def __init__(self, *args, **kwargs):
super(EditUserForm, self).__init__(*args, **kwargs)
self.department = None
class EditExtractorForm(Form):
departments = SelectMultipleField("Departments")
def __init__(self, *args, **kwargs):
super(EditExtractorForm, self).__init__(*args, **kwargs)
self.department = None
class NewInviteForm(Form):
department_id = SelectField("Department", coerce=int)
def __init__(self, *args, **kwargs):
super(NewInviteForm, self).__init__(*args, **kwargs)
| {
"repo_name": "codeforamerica/comport",
"path": "comport/admin/forms.py",
"copies": "1",
"size": "1918",
"license": "bsd-3-clause",
"hash": 580758411450185100,
"line_mean": 36.6078431373,
"line_max": 149,
"alpha_frac": 0.6819603754,
"autogenerated": false,
"ratio": 4.133620689655173,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.002276629218300698,
"num_lines": 51
} |
from flask_wtf import Form
from wtforms import (TextField, StringField, BooleanField,PasswordField,
validators)
from .utils import Unique
from .models import User
from .constants import (USER_LEN_MSG, USER_REQ_MSG, USER_DUPL_MSG,
EMAIL_FORMAT_MSG, EMAIL_REQ_MSG, EMAIL_DUPL_MSG,
PWD_REQ_MSG, PWD_LEN_MSG, PWD_MATCH_MSG, INCORRECT_PWD)
class LoginForm(Form):
username = TextField('Username',
[validators.Length(max=25,message=USER_LEN_MSG),
validators.Required(message=USER_REQ_MSG)])
password = PasswordField('Password',
[validators.Required(message=PWD_REQ_MSG)])
class SignupForm(Form):
username = TextField('Username', [validators.Length(max=25,
message=USER_LEN_MSG),
validators.Required(message=USER_REQ_MSG),
Unique(User,User.username, message=USER_DUPL_MSG)])
email = TextField('Email', [validators.Email(message=EMAIL_FORMAT_MSG),
validators.Required(message=EMAIL_REQ_MSG),
Unique(User, User.email, message=EMAIL_DUPL_MSG)])
password = PasswordField('Password', [validators.Length(max=25,
message=PWD_REQ_MSG),
validators.InputRequired(message=PWD_REQ_MSG),
validators.EqualTo('confirm',
message=PWD_MATCH_MSG)])
confirm = PasswordField('Repeat Password')
| {
"repo_name": "ma3lstrom/manga-cork",
"path": "mangacork/forms.py",
"copies": "1",
"size": "1649",
"license": "mit",
"hash": -4836869245424577000,
"line_mean": 48.9696969697,
"line_max": 79,
"alpha_frac": 0.5512431777,
"autogenerated": false,
"ratio": 4.444743935309973,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5495987113009974,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, SubmitField, validators, PasswordField, HiddenField, BooleanField
from models import User, Game, Deck
from wtforms.ext.sqlalchemy.fields import QuerySelectField
class SignupForm(Form):
username = TextField('Username', [
validators.Required('Please enter your username.'),
validators.Length(max=30, message='Username is at most 30 characters.'),
])
email = TextField('Email', [
validators.Required('Please enter your email address.'),
validators.Email('Please enter your email address.')
])
password = PasswordField('Password', [
validators.Required('Please enter a password.'),
validators.Length(min=6, message='Passwords is at least 6 characters.'),
validators.EqualTo('confirm', message='Passwords must match')
])
confirm = PasswordField('Repeat Password')
submit = SubmitField('Create account')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(username = self.username.data).first()
if user:
self.username.errors.append('That username is already taken.')
return False
else:
return True
class LoginForm(Form):
username = TextField('Username', [
validators.Required('Please enter your username.'),
validators.Length(max=30, message='Username is at most 30 characters.'),
])
password = PasswordField('Password', [
validators.Required('Please enter a password.'),
validators.Length(min=6, message='Passwords is at least 6 characters.'),
])
submit = SubmitField('Sign In')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(username = self.username.data).first()
if user and user.check_password(self.password.data):
return True
else:
self.password.errors.append('Invalid e-mail or password')
return False
def deck_query():
return Deck.query.all()
class CreateGameForm(Form):
user_id = HiddenField('user_id')
submit = SubmitField('Create Game')
deck = QuerySelectField(query_factory=deck_query, get_label='name')
reversed = BooleanField('Is Open')
def __init__(self, current_user, *args, **kwargs):
self.current_user_id = current_user.id
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
user = User.query.get(self.user_id.data)
if not user or user.id != self.current_user_id:
self.user_id.errors.append('Invalid user')
return False
else:
return True
class JoinGameForm(Form):
game_id = HiddenField('game_id')
user_id = HiddenField('user_id')
submit = SubmitField('Join Game')
def __init__(self, current_user, *args, **kwargs):
self.current_user_id = current_user.id
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
game = Game.query.get(self.game_id.data)
if not game or game.status != 'created':
return False
else:
return True
| {
"repo_name": "vigov5/pvp-game",
"path": "app/forms.py",
"copies": "1",
"size": "3491",
"license": "mit",
"hash": 3597397320502494700,
"line_mean": 32.8932038835,
"line_max": 96,
"alpha_frac": 0.621311945,
"autogenerated": false,
"ratio": 4.136255924170616,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.005125258592241195,
"num_lines": 103
} |
from flask_wtf import Form
from wtforms import TextField, SubmitField, validators, PasswordField
from wtforms_alchemy import model_form_factory
from app.user.models import User
ModelForm = model_form_factory(Form)
class SignupForm(Form):
email = TextField('Email', [
validators.Length(max=40, message='email is at most 40 characters.'),
validators.Required('Please enter your email address.'),
validators.Email('Please enter your email address.')
])
student_id = TextField('Student ID', [
validators.Required('Please enter your student id'),
])
submit = SubmitField('Create account')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
email = User.query.filter_by(email=self.email.data).first()
if email:
self.email.errors.append('That email is already taken.')
return False
student_id = User.query.filter_by(student_id=self.student_id.data).first()
if student_id:
self.student_id.errors.append('That student ID is already taken.')
return False
return True
class LoginForm(Form):
email = TextField('Email', [
validators.Length(max=40, message='email is at most 40 characters.'),
validators.Required('Please enter your email address.'),
validators.Email('Please enter your email address.')
])
password = PasswordField('Password', [
validators.Required('Please enter a password.'),
validators.Length(min=6, message='Passwords is at least 6 characters.'),
])
submit = SubmitField('Login In')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(email = self.email.data).first()
if user:
if not user.check_password(self.password.data):
self.password.errors.append('Wrong password')
return False
else:
return True
else:
self.password.errors.append('Invalid e-mail or password')
return False
class ResendMailForm(Form):
email = TextField('Email', [
validators.Length(max=40, message='email is at most 40 characters.'),
validators.Required('Please enter your email address.'),
validators.Email('Please enter a valid email address.')
])
submit = SubmitField('Resend Activation Email')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(email=self.email.data).first()
if not user:
self.email.errors.append('This email is not registered yet')
return False
else:
return True
class SendForgotPasswordForm(Form):
email = TextField('Email', [
validators.Length(max=40, message='email is at most 40 characters.'),
validators.Required('Please enter your email address.'),
validators.Email('Please enter a valid email address.')
])
submit = SubmitField('Send Forgot Password Email')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
user = User.query.filter_by(email=self.email.data).first()
if not user:
self.email.errors.append('This email is not registered yet')
return False
else:
return True
class ResetPasswordForm(Form):
new_password = PasswordField('Password', [
validators.Required('Please enter new password.'),
validators.Length(min=6, message='Passwords is at least 6 characters.'),
validators.EqualTo('new_confirm', message='Passwords must match')
])
new_confirm = PasswordField('Repeat Password')
submit = SubmitField('Reset password')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
return True
class ChangePasswordForm(Form):
new_password = PasswordField('Password', [
validators.Required('Please enter new password.'),
validators.Length(min=6, message='Passwords is at least 6 characters.'),
validators.EqualTo('new_confirm', message='Passwords must match')
])
new_confirm = PasswordField('Repeat Password')
submit = SubmitField('Change password')
def __init__(self, *args, **kwargs):
Form.__init__(self, *args, **kwargs)
def validate(self):
if not Form.validate(self):
return False
return True | {
"repo_name": "vigov5/oshougatsu2015",
"path": "app/user/forms.py",
"copies": "1",
"size": "4935",
"license": "mit",
"hash": -8017993459970777000,
"line_mean": 31.0519480519,
"line_max": 82,
"alpha_frac": 0.6184397163,
"autogenerated": false,
"ratio": 4.31758530183727,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.543602501813727,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, TextAreaField, FileField, validators, ValidationError
def checkfile(form,field):
if not field.data:
raise ValidationError('Gelieve een bestand te selecteren.')
filename=field.data.filename
if not '.' in filename:
raise ValidationError('Niet toegelaten bestandstype: %s' % filename)
else:
extension = filename.rsplit('.',1)[1].lower()
if not extension in ['png', 'jpg', 'jpeg', 'gif', 'svg', 'bmp', 'pdf']:
raise ValidationError('Niet toegelaten bestandstype: %s' % extension)
class OpmerkingBijBlad(Form):
naam = TextField(
'naam',
[validators.Required('Gelieve dit veld in te vullen.')])
email = TextField(
'email (optioneel)',
[validators.Optional()])
opmerking = TextAreaField(
'opmerking',
[validators.Required('Gelieve dit veld in te vullen.')])
class UploadBlad(Form):
attachment = FileField("afbeelding", [checkfile])
naam = TextField('naam', [validators.Required('Gelieve dit veld in te vullen.')])
email = TextField('email', [validators.Optional()])
titel = TextField('titel', [validators.Optional()])
auteur = TextField('tekst', [validators.Optional()])
melodie = TextField('melodie', [validators.Optional()])
voorgedragen_op = TextField('datum', [validators.Optional()])
extra = TextAreaField('extra info', [validators.Optional()])
| {
"repo_name": "berz/lossebladjes",
"path": "lossebladjes/forms.py",
"copies": "1",
"size": "1456",
"license": "bsd-3-clause",
"hash": -6506609308503316000,
"line_mean": 41.8235294118,
"line_max": 85,
"alpha_frac": 0.6627747253,
"autogenerated": false,
"ratio": 3.5686274509803924,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9689976052248006,
"avg_score": 0.008285224806477212,
"num_lines": 34
} |
from flask_wtf import Form
from wtforms import TextField, TextAreaField, FloatField, PasswordField, FileField
from wtforms import validators
from wtforms import ValidationError
from .models import User
class LoginForm(Form):
username = TextField(u'Username', validators=[validators.required()])
password = PasswordField(u'Password', validators=[validators.required()])
def validate(self):
check_validate = super(LoginForm, self).validate()
# Make sure the input was clean
if not check_validate:
return False
user = User.query.filter_by(username=self.username.data).first()
if not user:
self.username.errors.append('Invalid username or password')
return False
elif not user.check_password(self.password.data):
self.username.errors.append('Invalid username or password')
return False
return True
class NewUserForm(Form):
username = TextField(u'Username')
email = TextField(u'Email', validators=[validators.email()])
password = PasswordField(u'Password', validators=\
[validators.EqualTo('password2', message='Passwords must match.'),\
validators.length(6,64)])
password2 = PasswordField(u'Verify Password')
def validate_username(self, field):
if User.query.filter_by(username=field.data).first():
raise ValidationError('Username not available')
def validate_email(self, field):
if User.query.filter_by(email=field.data).first():
raise ValidationError('Email address not available')
def validate(self):
check_validate = super(NewUserForm, self).validate()
# Make sure the input was clean
if not check_validate:
return False
return True
class EditProfileForm(Form):
username = TextField(u'Username')
email = TextField(u'Email', validators=[validators.email()])
password = PasswordField(u'Password', validators=\
[validators.EqualTo('password2', message='Passwords must match.'),\
validators.length(6,64)])
password2 = PasswordField(u'Password Verify')
api_key = TextField(u'API Key')
def validate(self):
check_validate = super(EditProfileForm, self).validate()
# Make sure the input was clean
if not check_validate:
return False
return True
class CreatePostForm(Form):
title = TextField(u'Title', validators=[validators.required(), validators.length(max=256)])
text = TextAreaField(u'Content', validators=[validators.required()])
latitude = FloatField(u'Latitude', validators=[validators.required()])
longitude = FloatField(u'Longitude', validators=[validators.required()])
def validate(self):
check_validate = super(CreatePostForm, self).validate()
# Make sure the input was clean
if not check_validate:
return False
return True
class CreateImageForm(Form):
title = TextField(u'Title', validators=[validators.required(), validators.length(max=256)])
image = FileField(u'Image', validators=[validators.required()])
caption = TextAreaField(u'Caption', validators=[validators.required(), validators.length(max=512)])
latitude = FloatField(u'Latitude')
longitude = FloatField(u'Longitude')
def validate(self):
check_validate = super(CreateImageForm, self).validate()
# Make sure the input was clean
if not check_validate:
return False
return True
| {
"repo_name": "dankolbman/travel_blahg",
"path": "blog/forms.py",
"copies": "1",
"size": "3333",
"license": "mit",
"hash": 8231977935835998000,
"line_mean": 31.6764705882,
"line_max": 101,
"alpha_frac": 0.7131713171,
"autogenerated": false,
"ratio": 4.1097410604192355,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.015113260159145374,
"num_lines": 102
} |
from flask_wtf import Form
from wtforms import TextField,TextAreaField
from wtforms.validators import DataRequired,ValidationError
from app import db
from app.common.models import Comment
class CommentForm(Form):
table_class = Comment
comment=TextAreaField('comment',
validators=[DataRequired()])
email=TextField('email',
validators=[DataRequired()])
username=TextField("username",
validators=[DataRequired()])
ur_url=TextField('ur_url',
validators=[DataRequired()])
instance=None
def __init__(self,table=None,*args, **kwargs):
if table is not None:
self.instance=table
self._copy_data_to_form()
def _copy_data_to_form(self):
self.comment.data = self.instance.comment
self.email.data = self.instance.email
self.username.data= self.instance.username
self.ur_url.data = self.instance.ur_url
def save(self):
if self.instance is None:
self.instance=self.table_class()
self.instance.comment=self.comment.data
self.instance.email=self.email.data
self.instance.username=self.username.data
self.instance.ur_url=self.ur_url.data
db.session.add(self.instance)
db.session.commit()
| {
"repo_name": "xluren/awesome_flask",
"path": "simple_sqlalchemy/app/common/forms.py",
"copies": "1",
"size": "1354",
"license": "mit",
"hash": 2903541876369243000,
"line_mean": 32.85,
"line_max": 62,
"alpha_frac": 0.6255539143,
"autogenerated": false,
"ratio": 4.090634441087613,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5216188355387613,
"avg_score": null,
"num_lines": null
} |
from flask_wtf import Form
from wtforms import TextField, TextAreaField, SelectField, PasswordField, BooleanField, FileField, validators
from wtforms.validators import Required, EqualTo, Email
class DonationUploadForm(Form):
organization = SelectField('Organization:', choices=[('Other', "Other"), ('United Health', "United Health"), ('Austin Goodwill', "Austin Goodwill"), ('ASGA Austin', "ASGA Austin")], default='1')
frequency = SelectField('Frequency:', choices=[('1', "One-off"), ('2', "Recurring")], default='1')
recurring_number = TextField('Number Per Year')
amount = TextField('Amount', [validators.Required()])
payment_type = SelectField('Payment Type', choices=[('1', "Credit Card"), ('2', "Bank Transfer"), ('3', "Cash")], default='1')
description = TextField('Description:', [validators.Required()])
upload_file = FileField('Choose image file (max 1MB):')
receipt = BooleanField('Receipt:')
class PledgingForm(Form):
organization = SelectField('Organization:', choices=[('1', "Other"), ('2', "United Health"), ('3', "Austin Goodwill"), ('4', "ASGA Austin")], default='1')
frequency = SelectField('Frequency:', choices=[('1', "One-off"), ('2', "Recurring")], default='1')
recurring_number = TextField('Number Per Year')
amount = TextField('Amount', [validators.Required()])
description = TextField('Description:', [validators.Required()]) | {
"repo_name": "teamgivn/givnapp",
"path": "app/blueprints/donors/forms.py",
"copies": "1",
"size": "1405",
"license": "mit",
"hash": 3926536609424217600,
"line_mean": 65.9523809524,
"line_max": 198,
"alpha_frac": 0.6782918149,
"autogenerated": false,
"ratio": 3.7870619946091644,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4965353809509164,
"avg_score": null,
"num_lines": null
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.