def clear_databases(): EnzymeType.drop_collection() Sequence.drop_collection() Paper.drop_collection() Reaction.drop_collection() Activity.drop_collection() Molecule.drop_collection()
def get_enzyme_paper_progress(enzyme_type_obj): enz_type = enzyme_type_obj.enzyme_type num_papers = len(Paper.objects(tags=enz_type)) num_complete_papers = len( Paper.objects( db.Q(tags=enz_type) & (db.Q(status='Complete') | db.Q(status='Complete - Awaiting review')))) if num_papers == 0: progress = [ "0%", f"{num_complete_papers} out of {num_papers}", 'bg-danger', enzyme_type_obj.full_name ] elif num_complete_papers == 0: progress = [ "0%", f"{num_complete_papers} out of {num_papers}", 'bg-danger', enzyme_type_obj.full_name ] else: pc_complete = round((num_complete_papers / num_papers) * 100, 1) if pc_complete > 80: colour = 'bg-success' elif pc_complete > 40: colour = 'bg-warning' else: colour = 'bg-danger' progress = [ f"{pc_complete}%", f"{num_complete_papers} out of {num_papers}", colour, enzyme_type_obj.full_name ] return progress
def high_importance_papers(): hi_papers = Paper.objects(high_importance=True).select_related() enzyme_types = EnzymeType.objects() tags = [] for paper in hi_papers: for tag in paper.tags: if tag not in tags: tags.append(str(tag)) tags = sorted(tags) data_by_tag = {} for tag in tags: hi_q = db.Q(high_importance=True) tag_q = db.Q(tags=tag) papers_data = list( Paper.objects(hi_q & tag_q).only( *papers_table.PAPERS_TABLE_FIELDS).order_by( '-status').as_pymongo()) papers_data = papers_table.process_papers_dict(papers_data, show_owner=False) data_by_tag[tag] = papers_data enzyme_full_names = {} for enz_type in enzyme_types: enzyme_full_names[enz_type.enzyme_type] = enz_type.full_name return render_template('edit_tables/high_importance_papers.html', data_by_tag=data_by_tag, tags=tags, enzyme_full_names=enzyme_full_names)
def inject_login_mode(): inject_dict = {} inject_dict['login_mode'] = app.config['USE_EMAIL_CONFIRMATION'] if current_user.is_authenticated: user = User.objects(id=current_user.id).select_related()[0] if user.has_role('enzyme_teams') and user.enzyme_teams is not None: inject_dict['enzyme_teams'] = [enz_type_obj.enzyme_type for enz_type_obj in user.enzyme_teams] if user.has_role('enzyme_champion') and user.enzyme_champion is not None: inject_dict['enzyme_champion'] = [enz_type_obj.enzyme_type for enz_type_obj in user.enzyme_champion] if user.has_role('contributor'): inject_dict['user_papers_need_data'] = len(Paper.objects(Q(owner=user) & (Q(status='Data required') | Q(status='Enzymes need protein sequences') | Q(status='Issues need to be resolved')))) inject_dict['user_seqs_need_data'] = len(Sequence.objects(Q(owner=user) & ((Q(sequence=None)|Q(sequence='')) & (Q(sequence_unavailable__ne=True))))) inject_dict['total_team_notifications'] = 0 inject_dict['team_notifications'] = {} inject_dict['champ_seq_notifications'] = {} inject_dict['champ_notifications'] = {} if 'enzyme_teams' in inject_dict: for enz_type in inject_dict['enzyme_teams']: num_papers = len(Paper.objects(Q(tags=enz_type) & Q(owner=None) & (Q(status='Data required') | Q(status='Enzymes need protein sequences')))) inject_dict['team_notifications'][enz_type] = num_papers inject_dict['total_team_notifications'] += num_papers if 'enzyme_champion' in inject_dict: for enz_type in inject_dict['enzyme_champion']: num_papers = len(Paper.objects(Q(tags=enz_type) & Q(status='Complete - Awaiting review'))) num_seqs = len(Sequence.objects(Q(enzyme_type=enz_type) & ((Q(sequence=None)|Q(sequence='')) & (Q(sequence_unavailable__ne=True))))) inject_dict['champ_notifications'][enz_type] = num_papers inject_dict['champ_seq_notifications'][enz_type] = num_seqs inject_dict['total_team_notifications'] += num_papers + num_seqs return inject_dict
def submit_comment(): if current_user.is_authenticated: user = user_datastore.get_user(current_user.id) else: user = None parent_type = request.form['parent_type'] parent_id = request.form['parent_id'] comment_text = request.form['comment'] comment_id = request.form['comment_id'] if comment_id != '': comment_obj = Comment.objects(id=comment_id)[0] if current_user.has_role( 'rxn_rules_admin') or comment_obj.owner == user: comment_obj.text = comment_text comment_obj.save() else: result = { 'status': 'danger', 'msg': 'Could not edit comment - no access', 'issues': [] } return jsonify(result=result) else: comment_obj = Comment(owner=user, text=comment_text) comment_obj.save() if parent_type == 'issue': issue = Issue.objects(id=parent_id)[0] issue.comments.append(comment_obj) issue.save() elif parent_type == 'activity_issue': issue = ActivityIssue.objects(id=parent_id)[0] issue.comments.append(comment_obj) issue.save() elif parent_type == 'reaction_suggestion': r_sug = ReactionSuggestion.objects(id=parent_id)[0] r_sug.comments.append(comment_obj) r_sug.save() elif parent_type == 'paper': paper = Paper.objects(id=parent_id)[0] paper.comments.append(comment_obj) paper.save() elif parent_type == 'paper': paper = Paper.objects(id=parent_id)[0] paper.comments.append(comment_obj) paper.save() result = {'status': 'success', 'msg': 'Comment submitted', 'issues': []} return jsonify(result=result)
def task_autoprocess(): ap = AutoProcessor() paper_ids = list(Paper.objects(status='Complete').distinct('_id')) for id in paper_ids: paper = Paper.objects(id=id)[0] try: ap.auto_process(paper) except Exception as e: print() print(f'WARNING - ERROR PROCESSING PAPER - {paper.short_citation}') print() print(e) print()
def papers_that_need_data(): user = user_datastore.get_user(current_user.id) title = "Papers that require curating" args = request.args.to_dict() q_no_user = db.Q(owner=None) q_no_data = db.Q(status__nin=['Complete - Awaiting review', 'Complete']) if 'enzyme_type' in args: q_e_type = db.Q(tags=args['enzyme_type']) title += f" - {args['enzyme_type']}" else: q_e_type = db.Q() papers_data = list( Paper.objects(q_no_user & q_no_data & q_e_type).only( *papers_table.PAPERS_TABLE_FIELDS).order_by( '-status').as_pymongo()) papers_data = papers_table.process_papers_dict(papers_data, show_owner=False) return render_template('edit_tables/edit_papers.html', papers_data=papers_data, papers_table_height='80vh', papers_button_columns=['self_assign'], show_owner=False, title=title, row_click_modal=False)
def self_assign(): paper = Paper.objects(id=request.form['paper_id'])[0] user = user_datastore.get_user(current_user.id) if papers_functions.can_self_assign(user) == False: result = { 'status': 'danger', 'msg': 'Can not assign paper', 'issues': [ 'Users may not have more papers assigned to them than the number they have completed', 'Please complete papers already assigned to you before taking on additional papers' ] } return jsonify(result=result) if paper.owner == None: paper.owner = user paper.save() result = { 'status': 'success', 'msg': 'Paper is now assigned to you', 'issues': [] } flash("Paper is now assigned to you", 'success') return jsonify(result=result) else: result = { 'status': 'danger', 'msg': 'Could not assign, paper already belongs to another user', 'issues': [] } return jsonify(result=result)
def update_paper_molecule(): paper_id = request.form['paper_id'] id = request.form['id'] smi = request.form['smi'] name = request.form['name'] paper_query = Paper.objects(id=paper_id).select_related() if len(paper_query) != 0: paper = paper_query[0] if check_permission.check_paper_permission(current_user.id, paper): act_mol = ActivityMol.objects(id=id)[0] if smi != act_mol.smi: try: mol = Chem.MolFromSmiles(smi) svg = moltosvg(mol) except: svg = "" act_mol.svg = svg act_mol.smi = smi act_mol.name = name act_mol.save() result = {'status': 'success', 'msg': 'Molecule saved', 'issues': []} return jsonify(result=result) result = {'status': 'danger', 'msg': 'Could not delete molecule', 'issues': []} return jsonify(result=result)
def papers_with_orhpan_sequences(): title = "Papers with orphan sequences" activity_enzyme_names = list( set(Activity.objects().distinct('enzyme_name'))) paper_ids = [] for name in activity_enzyme_names: if len(Sequence.objects(enzyme_name=name)) == 0: act = Activity.objects(enzyme_name=name)[0] paper_ids.append(act.paper) papers_data = list( Paper.objects(id__in=paper_ids).only( *papers_table.PAPERS_TABLE_FIELDS).order_by( '-status').as_pymongo()) papers_data = papers_table.process_papers_dict(papers_data, show_owner=False) return render_template('edit_tables/edit_papers.html', papers_data=papers_data, papers_table_height='80vh', papers_button_columns=['delete', 'edit'], show_owner=True, title=title, row_click_modal=False)
def query_crossref(): paper = Paper.objects(id=request.form['paper_id'])[0] doi = str(paper.doi).replace(' ', '') title, authors_list, journal, date, cite_mini = papers_crossref.get_metadata_from_crossref( doi) print(f"{title}, {authors_list}, {journal}, {type(date)}, {cite_mini}") if cite_mini == '': result = { 'status': 'danger', 'msg': 'DOI not found in crossref', 'issues': [] } else: paper_dict = { 'short_cit': cite_mini, 'doi': doi, 'date': str(date), 'title': title, 'journal': journal, 'authors': papers_functions.list_to_string(authors_list) } result = { 'status': 'success', 'msg': 'Fields updated, click save to update the database', 'issues': [], 'paper': paper_dict } return jsonify(result=result)
def duplicate_paper_molecule(): id = request.form['id'] paper_id = request.form['paper_id'] paper_query = Paper.objects(id=paper_id).select_related() if len(paper_query) != 0: paper = paper_query[0] if check_permission.check_paper_permission(current_user.id, paper): mols = ActivityMol.objects(db.Q(id=id)) if len(mols) != 0: mol = mols[0] num_paper_mols = ActivityMol.objects(paper=paper).count() new_mol = ActivityMol(name=f"{num_paper_mols+1}", smi=mol.smi, svg=mol.svg, paper=paper) new_mol.save() mol_list = [(new_mol.name, new_mol.smi, new_mol.svg, str(new_mol.id))] result = {'status': 'success', 'msg': 'Molecule deleted', 'issues': [], 'mol_list': mol_list} return jsonify(result=result) result = {'status': 'danger', 'msg': 'Could not delete molecule', 'issues': []} return jsonify(result=result)
def edit_papers(): papers_data = list(Paper.objects().only(*papers_table.PAPERS_TABLE_FIELDS).order_by('-status').as_pymongo()) papers_data = papers_table.process_papers_dict(papers_data) return render_template('edit_tables/edit_papers.html', papers_data=papers_data, papers_table_height='80vh', papers_button_columns=['delete', 'edit', 'link'], show_owner=True, title="Super contributor access to all papers", row_click_modal=False)
def show_papers(): args = request.args.to_dict() title = "Papers" if 'reviewed' in args: revQ = db.Q(reviewed=True) else: revQ = db.Q() status_query = db.Q(status_not='Data required') if 'enzyme_type' in args: enzyme_type_query = db.Q(tags=args['enzyme_type']) title += f" - featuring {args['enzyme_type']} enzymes" else: enzyme_type_query = db.Q() papers = Paper.objects(enzyme_type_query & revQ) if 'enzyme_name' in args: papers = filter_papers_by_enzyme_name(papers, args['enzyme_name']) title += f" - featuring {args['enzyme_name']}" if 'reaction' in args: papers = filter_papers_by_reaction(papers, args['reaction']) title += f" - featuring a {args['reaction']} reaction" paper_ids = [paper.id for paper in papers] papers_data = list( Paper.objects(id__in=paper_ids).only( *papers_table.PAPERS_TABLE_FIELDS).order_by( '-status').as_pymongo()) papers_data = papers_table.process_papers_dict(papers_data) return render_template('edit_tables/edit_papers.html', papers_data=papers_data, papers_table_height='80vh', papers_button_columns=[], show_owner=True, title=title, row_click_modal=True)
def admin_set_owner(): paper = Paper.objects(id=request.form['paper_id'])[0] new_owner_id = request.form['new_owner_id'] print(new_owner_id) new_owner = User.objects(id=new_owner_id)[0] paper.owner = new_owner paper.save() result = {'status': 'success', 'msg': 'Paper owner updated', 'issues': []} return jsonify(result=result)
def paper_issues(): paper = Paper.objects(id=request.form['paper_id'])[0] if check_permission.check_seq_permissions(current_user.id, paper): issues = bool(strtobool(request.form['issues'])) paper.has_issues = issues paper.save() result = { 'status': 'success', 'msg': 'Issue status updated', 'issues': [] } return jsonify(result=result)
def importance_updated(): paper = Paper.objects(id=request.form['paper_id'])[0] if check_permission.check_seq_permissions(current_user.id, paper): importance = bool(strtobool(request.form['importance'])) paper.high_importance = importance paper.save() result = { 'status': 'success', 'msg': 'Importance updated', 'issues': [] } return jsonify(result=result)
def admin_all_seqs_to_owner(): paper = Paper.objects(id=request.form['paper_id']).select_related()[0] seqs = Sequence.objects(db.Q(papers=paper)) for seq in seqs: seq.owner = paper.owner seq.save() result = { 'status': 'success', 'msg': 'All sequences assigned to paper owner', 'issues': [] } return jsonify(result=result)
def admin_activity_to_owner(): paper = Paper.objects(id=request.form['paper_id']).select_related()[0] activities = Activity.objects(paper=paper) for activity in activities: activity.added_by = paper.owner activity.save() result = { 'status': 'success', 'msg': 'Activity added by updated', 'issues': [] } return jsonify(result=result)
def my_papers(): user = user_datastore.get_user(current_user.id) papers_data = list(Paper.objects(owner=user).only(*papers_table.PAPERS_TABLE_FIELDS).order_by('-status').as_pymongo()) papers_data = papers_table.process_papers_dict(papers_data) papers_button_columns = ['edit'] if user.has_role('paper_adder'): papers_button_columns.append('delete') return render_template('edit_tables/edit_papers.html', papers_data=papers_data, papers_table_height='80vh', papers_button_columns=papers_button_columns, show_owner=True, title=f"Papers assigned to {user.first_name} {user.last_name}", row_click_modal=False)
def submission_main_page(paper_id): user = user_datastore.get_user(current_user.id) paper_query = Paper.objects(id=paper_id).select_related() if len(paper_query) == 0: flash('Paper has not been added yet, please add to the database first', 'fail') return redirect(url_for("biocatdb.launch_add_paper")) paper = paper_query[0] if not check_permission.check_paper_permission(current_user.id, paper): flash('No access to edit this entry', 'fail') return redirect(url_for("biocatdb.launch_add_paper")) paper_data = get_paper_data(paper, user) activity_data = get_activity_data(paper) reactions = list(Reaction.objects().distinct('name')) enzyme_names = list(Sequence.objects(papers=paper).distinct('enzyme_name')) enzyme_types = list(EnzymeType.objects().distinct('enzyme_type')) enzyme_data = sequence_table.get_enzyme_data(db.Q(papers=paper)) enzyme_types_in_paper = list(Sequence.objects(papers=paper).distinct('enzyme_type')) reactions_in_paper = list(Reaction.objects(enzyme_types__in=enzyme_types_in_paper).distinct('name')) reactions_in_activity = list(Activity.objects(paper=paper).distinct('reaction')) status_dict = get_status(paper, user) comments = get_comments(paper, user) paper_molecules = get_paper_molecules(paper) admin_panel = False admin_dict = {} if current_user.has_role('admin'): admin_panel = True admin_dict = get_admin_dict(paper) reactions_ordered = reactions_in_activity + [r for r in reactions_in_paper if r not in reactions_in_activity] reactions_ordered += [r for r in reactions_in_paper if r not in reactions_ordered] reactions_ordered += [r for r in reactions if r not in reactions_ordered] return render_template('data_submission/submission_main_page.html', paper=paper_data, activity_data=activity_data, seq_data=enzyme_data, seq_button_columns=['edit', 'remove', 'papers'], status=status_dict, seq_table_height='60vh', enzyme_types=enzyme_types, show_header_filters=False, include_owner=True, lock_enz_type='false', reactions=reactions_ordered, enzyme_names=enzyme_names+['Chemical'], doi=paper.doi, comments=comments, paper_molecules=paper_molecules, admin_panel=admin_panel, admin_dict=admin_dict, enzyme_reactions=reactions_in_paper)
def enzyme_champion_papers(enzyme_type): user = user_datastore.get_user(current_user.id) enzyme_type_obj = EnzymeType.objects(enzyme_type=enzyme_type)[0] if enzyme_type_obj not in user.enzyme_champion: flash('No access', 'danger') return redirect(url_for('main_site.home')) papers_data = list(Paper.objects(tags=enzyme_type).only(*papers_table.PAPERS_TABLE_FIELDS).order_by('-status').as_pymongo()) papers_data = papers_table.process_papers_dict(papers_data) return render_template('edit_tables/edit_papers.html', papers_data=papers_data, papers_table_height='80vh', papers_button_columns=['delete', 'edit'], show_owner=True, title=f"Enzyme champion for {enzyme_type} papers", row_click_modal=False)
def save_paper(): user = user_datastore.get_user(current_user.id) paper = Paper.objects(id=request.form['paper_id'])[0] if not check_permission.check_paper_permission(current_user.id, paper): result = { 'status': 'danger', 'msg': 'No access to edit this paper', 'issues': [], 'redirect': url_for("biocatdb.launch_add_paper") } return jsonify(result=result) paper.short_citation = request.form['short_cit'] paper.doi = request.form['doi'].replace(' ', '') paper.html = 'https://doi.org/' + request.form['doi'] if request.form['date'] != "": paper.date = request.form['date'] paper.title = request.form['title'] paper.journal = request.form['journal'] paper.authors = request.form['authors'].split(', ') paper.tags = request.form['tags'].split(', ') if user not in paper.edits_by: paper.edits_by.append(user) if (paper.owner == user) and (request.form['self_assign'] == 'false'): paper.owner = None paper.save() unassign_seqs_in_paper(user, paper) if not current_user.has_role('super_contributor'): result = { 'status': 'warning', 'msg': 'Paper no longer assigned to you', 'issues': [], 'redirect': url_for("biocatdb.launch_add_paper") } return jsonify(result=result) elif request.form['self_assign'] == 'true': paper.owner = user paper.save() papers_functions.tag_paper_with_enzyme_types(paper) result = { 'status': 'success', 'msg': 'Paper information updated', 'issues': [] } return jsonify(result=result)
def paper_substrate_specificity(paper_id): paper = Paper.objects(id=paper_id)[0] title = f"{paper.short_citation} activity data" args = request.args.to_dict() if 'reviewed' in args: revQ = db.Q(reviewed=True) else: revQ = db.Q() paper_Q = db.Q(paper=paper) activity_data = list(Activity.objects(paper_Q & revQ).only(*process_activity_data.mongo_cols).as_pymongo()) activity_data = process_activity_data.process_activity_data(activity_data) activity_data = process_activity_data.smiles_to_svg(activity_data) return render_template('substrate_specificity/table_result_specificity.html', substrate_specificity_data=activity_data, title=title)
def load_paper_data(): paper = Paper.objects(id=request.form['paper_id'])[0].select_related() authors_str = "" for author in paper.authors: authors_str += f"{author}, " authors_str = authors_str[0:-2] if paper.owner is None: owner = '' else: owner = f"{paper.owner.first_name} {paper.owner.last_name}, {paper.owner.affiliation}" tags_str = "" for tag in paper.tags: tags_str += f"{tag}, " tags_str = tags_str[0:-2] if len(paper.authors) != 0: v_short_cit = f"{paper.authors[0]} et al" else: v_short_cit = paper.title[0:10] + '..' if paper.date != None: date = paper.date.strftime('%B-%Y') else: date = None result = { 'title': paper.title, 'authors': authors_str, 'owner': owner, 'journal': paper.journal, 'date': date, 'tags': tags_str, 'status': paper.status, 'doi': paper.doi, 'paper_id': str(paper.id), 'v_short_cit': f"<i>{v_short_cit}</i>" } return jsonify(result=result)
def update_reviewed_status(): papers = Paper.objects(reviewed=True) for paper in papers: acts = Activity.objects(paper=paper) seqs = Sequence.objects(papers=paper) for act in acts: act.reviewed = True act.save() for seq in seqs: seq.reviewed = True seq.save() result = { 'status': 'success', 'msg': f'Updated activity and sequence data to reviewed = True, if paper has been reviewed', 'issues': [] } return jsonify(result=result)
def task_process_images(list_filenames, paper_id, start_num=1): osra_url = current_app.config['OSRA_API_HOST'] paper = Paper.objects(id=paper_id)[0] job = get_current_job() job.meta['progress'] = 'started' job.save_meta() dict_smiles = {} n = start_num for i, filename in enumerate(list_filenames): new_smis = structure_recognition.process_image(filename, osra_url, log=True) for j, smi in enumerate(new_smis): name = f"{n}" dict_smiles[name] = smi n += 1 for name, smi in dict_smiles.items(): structure_recognition.save_mol(smi, paper, name=name) return dict_smiles
def upload_sequence_excel(): issues = [] if request.method != 'POST': issues.append('Method is not POST') else: excel_file = request.files['file_seq'] paper = Paper.objects(id=request.form['paper_id_field'])[0] filename = secure_filename(excel_file.filename) if filename[-5:] == '.xlsx': excel_file.save(filename) df = pd.read_excel(filename) data_list = process_uploaded_excel(df) os.remove(filename) save_issues = save_or_add_seqs(data_list, paper) if len(save_issues) == 0: result = { 'status': 'success', 'msg': 'Sequences saved and added to paper', 'issues': [] } flash("Sequences saved and added to paper", "success") else: result = { 'status': 'warning', 'msg': 'Sequences saved with some issues:', 'issues': save_issues } flash("Sequences saved with some issues", "warning") return jsonify(result=result) else: issues.append('File does not end in .xlsx') result = { 'status': 'danger', 'msg': 'Error processing file', 'issues': issues } return jsonify(result=result)
def review_paper(): user = user_datastore.get_user(current_user.id) paper = Paper.objects(id=request.form['paper_id'])[0] acts = Activity.objects(paper=paper) seqs = Sequence.objects(papers=paper).select_related() if check_permission.check_seq_permissions(current_user.id, paper): reviewed = bool(strtobool(request.form['reviewed'])) paper.reviewed = reviewed if reviewed == True: paper.reviewed_by = user else: paper.reviewed_by = None paper.save() for act in acts: act.reviewed = reviewed act.save() if reviewed == True: for seq in seqs: seq.reviewed = True seq.save() else: for seq in seqs: has_reviewed_paper = False for paper in seq.papers: if paper.reviewed == True: has_reviewed_paper = True break if has_reviewed_paper == False: seq.reviewed = False seq.save() result = { 'status': 'success', 'msg': 'Review status updated', 'issues': [] } return jsonify(result=result)
def task_assign_papers(): users = User.objects() papers = Paper.objects() for paper in papers: paper_status.update_status(paper) for user in users: usernames = get_usernames(user) for paper in papers: if paper.added_by is None or paper.added_by == '': activities = Activity.objects(paper=paper) for activity in activities: if does_username_match(usernames, activity.added_by_string): activity.added_by = user activity.save() if paper.added_by is None or paper.added_by == '': paper.added_by = user paper.owner = user paper.save()