def sign_up(): """Sign-up request.""" if flask_login.current_user.is_authenticated: session['logged_in'] = True return redirect(url_for('ramp.problems')) form = UserCreateProfileForm() if form.validate_on_submit(): user = add_user(session=db.session, name=form.user_name.data, password=form.password.data, lastname=form.lastname.data, firstname=form.firstname.data, email=form.email.data, linkedin_url=form.linkedin_url.data, twitter_url=form.twitter_url.data, facebook_url=form.facebook_url.data, google_url=form.google_url.data, github_url=form.github_url.data, website_url=form.website_url.data, bio=form.bio.data, is_want_news=form.is_want_news.data, access_level='asked') admin_users = User.query.filter_by(access_level='admin') for admin in admin_users: subject = 'Approve registration of {}'.format( encode_string(user.name)) body = body_formatter_user(user) url_approve = ('http://www.ramp.studio/sign_up/{}'.format( encode_string(user.name))) body += 'Click on the link to approve the registration ' body += 'of this user: {}'.format(url_approve) send_mail(admin.email, subject, body) return redirect(url_for('auth.login')) return render_template('sign_up.html', form=form)
def __repr__(self): return ("User(name={}, lastname={}, firstname={}, email={}, " "admined_teams={})".format(encode_string(self.name), encode_string(self.lastname), encode_string(self.firstname), encode_string(self.email), self.admined_teams))
def body_formatter_user(user): """Create the body of an email using the user information. Parameters ---------- user : :class:`ramp_database.model.User` The user profile. Returns ------- body : str The email body. """ body = """ user = {} name = {} {} email = {} linkedin = {} twitter = {} facebook = {} github = {} notes = {} bio = {} """.format(encode_string(user.name), encode_string(user.firstname), encode_string(user.lastname), user.email, user.linkedin_url, user.twitter_url, user.facebook_url, user.github_url, encode_string(user.hidden_notes), encode_string(user.bio)) return body
def test_encode_string(): if six.PY3: string = encode_string('a string') assert isinstance(string, bytes) string = encode_string(b'a string') assert isinstance(string, bytes) else: string = encode_string('a string') assert isinstance(string, bytes)
def test_problem_model(session_scope_module): problem = get_problem(session_scope_module, 'iris') assert (repr(problem) == "Problem({})\nWorkflow(Classifier)\n\tWorkflow(Classifier): " "WorkflowElement(classifier)".format(encode_string('iris'))) # check that we can access the problem module and that we have one of the # expected function there. assert hasattr(problem.module, 'get_train_data') assert problem.title == 'Iris classification' assert issubclass(problem.Predictions, BasePrediction) X_train, y_train = problem.get_train_data() assert X_train.shape == (120, 4) assert y_train.shape == (120, ) X_test, y_test = problem.get_test_data() assert X_test.shape == (30, 4) assert y_test.shape == (30, ) gt_train = problem.ground_truths_train() assert hasattr(gt_train, 'label_names') assert gt_train.y_pred.shape == (120, 3) gt_test = problem.ground_truths_test() assert hasattr(gt_test, 'label_names') assert gt_test.y_pred.shape == (30, 3) gt_valid = problem.ground_truths_valid([0, 1, 2]) assert hasattr(gt_valid, 'label_names') assert gt_valid.y_pred.shape == (3, 3) assert isinstance(problem.workflow_object, Classifier)
def test_event_team_model(session_scope_module): event = get_event(session_scope_module, 'iris_test') team = get_team_by_name(session_scope_module, 'test_user') event_team = (session_scope_module.query(EventTeam).filter( EventTeam.event_id == event.id).filter( EventTeam.team_id == team.id).one()) assert repr(event_team) == "Event(iris_test)/Team({})".format( encode_string('test_user'))
def sign_up_for_event(event_name): """Landing page to sign-up to a specific RAMP event. Parameters ---------- event_name : str The name of the event. """ event = get_event(db.session, event_name) if not is_accessible_event(db.session, event_name, flask_login.current_user.name): return redirect_to_user(u'{}: no event named "{}"'.format( flask_login.current_user.firstname, event_name)) if app.config['TRACK_USER_INTERACTION']: add_user_interaction(db.session, interaction='signing up at event', user=flask_login.current_user, event=event) ask_sign_up_team(db.session, event.name, flask_login.current_user.name) if event.is_controled_signup: admin_users = User.query.filter_by(access_level='admin') for admin in admin_users: subject = ('Request to sign-up {} to RAMP event {}'.format( event.name, flask_login.current_user.name)) body = body_formatter_user(flask_login.current_user) url_approve = ( 'https://www.ramp.studio/events/{}/sign_up/{}'.format( event.name, encode_string(flask_login.current_user.name))) body += ('Click on this link to approve the sign-up request: {}'. format(url_approve)) send_mail(admin, subject, body) return redirect_to_user("Sign-up request is sent to event admins.", is_error=False, category='Request sent') sign_up_team(db.session, event.name, flask_login.current_user.name) return redirect_to_sandbox(event, u'{} is signed up for {}.'.format( flask_login.current_user.firstname, event), is_error=False, category='Successful sign-up')
def __str__(self): return 'User({})'.format(encode_string(self.name))
def __repr__(self): return 'Problem({})\n{}'.format(encode_string(self.name), self.workflow)
def __repr__(self): return ( 'Team(name={}, admin_name={}, initiator={}, acceptor={})'.format( encode_string(self.name), encode_string(self.admin.name), self.initiator, self.acceptor))
def __repr__(self): return 'ScoreType(name={})'.format(encode_string(self.name))