def generate_token(user: User): _safecheck() token = ''.join(random.choice(string.ascii_letters) for i in range(10)) tk = DoorsCachedToken(token, user=user, expires_in=864000, issued_at=time.time()) user.update_token(tk) get_repo(User).save()
def cache_search_metabolite(mv: MetaboliteView, attrs=None) -> SearchItem: _requested_search_item = None _repo = get_repo(SearchItem) endpoint = _ENDPOINT.format(mv.meta_id) display = mv.primary_name # Todo: ITT: make names lowercase set everywhere for db_tag, db_ids in mv.refs: for db_id in db_ids: _repo.create(SearchItem(search_term=db_id, search_attr=db_tag, entity_id=mv.meta_id, endpoint=endpoint, display=display), commit=False) for attr, values in mv.attributes: for value in values: _repo.create(SearchItem(search_term=value, search_attr=attr, entity_id=mv.meta_id, endpoint=endpoint, display=display), commit=False) _repo.save()
def get_list(self): if not current_user.admin: return redirect('/users/login') users = get_repo(User).list_all() return render_template('/users/list.html', users=users)
def import_db(self, autoclear: bool = False): repo: LipidMapsDataRepository = get_repo(LipidMapsData) if repo.count() > 0: print("LipidMaps Data is not empty. Truncate the table? Y/n:", end="") if autoclear or input().lower() == 'y': print("Clearing DB") repo.delete_all() else: print("Exited") return i = 0 for me in parse_iter_sdf(self.path): # todo: do something with None (=mol struct) key me.pop(None, None) data: LipidMapsData = parse_lipidmaps(me) repo.create(data, commit=False) if i % 2000 == 0: print(f"\rInserting... {i}", end="") i += 1 if i % 10000 == 0: repo.save() print(" Committed") repo.save() print(" Committed everything to DB") ding.ding() ding.ding() ding.ding()
def get_devuser(): if not enabled: return None _safecheck() user = get_repo(User).find_by_username(devuser[0]) return user
def check_db(): try: w = get_repo(User).is_empty() return not w except: pass return True
def authenticate(username1, password1): if not enabled or devuser != (username1, password1): return None _safecheck() user = get_repo(User).find_by_username(username1) return user
def init(app, conf): global user_repo, user_manager, login_manager app.config["SECRET_KEY"] = conf.get("secret_key") login_manager.init_app(app) #login_manager.login_view = "Users.get_login" user_repo = get_repo(User) user_manager = UserManager(user_repo)
def init(app, c, entity): global login_manager, conf, user_repo, user_entity conf = c user_entity = entity user_repo = get_repo(user_entity) app.config["SECRET_KEY"] = conf.get("secret_key") login_manager.init_app(app) login_manager.login_view = 'doors.Users:get_auth' # oauth protector require_oauth.register_token_validator(DoorsTokenValidator())
def __init__(self, app): self.app = app # by default, the Examples.custom_route2 endpoint would be reached at 'localhost:5000/examples/custom_route2' # with the rule below, however, the new url is 'localhost:5000/example2' self.app.preset_endpoints({ 'GET /example2': 'Examples.custom_route2', }) self.users = get_repo(User) # you can of course put this in a separated code, without the class @app.route('/example1') def custom_route1(): return 'Custom route #1'
def post_edit(self): if not current_user.username or not current_user.admin: return redirect('/users/login') repo = get_repo(User) uid = request.form['uid'] user = repo.get(uid) user.admin = request.form["admin"] == '1' user.email = request.form["email"] user.username = request.form["username"] if not user.admin: user.admin = False repo.save() return redirect('/user/list')
def __init__(self, server): self.server = server self.group = 'CommentsApi' self.route = '' self.server.preset_endpoints({ 'GET /api/<entity_type>/<entity_id>/comments': 'CommentsApi:get', 'POST /api/<entity_type>/<entity_id>/comments': 'CommentsApi:post', #'PUT /api/<entity_type>/<entity_id>/comments': 'CommentsApi:put', 'DELETE /api/<entity_type>/<entity_id>/comments': 'CommentsApi:delete', }) self.repo: CommentRepository = get_repo(Comment)
def __init__(self, server): self.server = server self.users = get_repo(User) self.commands = { 'users:list': { 'help': 'Lists users', 'short': {}, 'long': [] }, 'users:setadmin': { 'help': 'Sets admin', 'short': {}, 'long': ['username='] }, }
def create_testentities(): user_repo = get_repo(User) user_manager = UserManager(user_repo) usrs = [ ('admin', '*****@*****.**', 'admin', True), ] for username, email, pw, adm in usrs: user = user_manager.create(username=username, email=email, admin=adm, **{ 'password': pw, 'password-confirm': pw })
def __init__(self, dbconf): self.name = 'lipidmaps' self.repo = get_repo(LipidMapsData) self.conf = dbconf self.padding = 'LM' self._select = ('pubchem_id', 'chebi_id', 'kegg_id', 'hmdb_id', 'lipidmaps_id', 'smiles', 'inchi', 'inchikey', 'formula', 'names', 'mass', 'ref_etc') self._reverse = ( 'pubchem_id', 'kegg_id', 'hmdb_id', 'chebi_id', )
def __init__(self, dbconf): self.name = 'chebi' self.repo = get_repo(ChEBIData) self.conf = dbconf self.padding = 'CHEBI:' self._select = ('chebi_id', 'pubchem_id', 'kegg_id', 'hmdb_id', 'lipidmaps_id', 'smiles', 'inchi', 'inchikey', 'formula', 'names', 'mass', 'monoisotopic_mass', 'ref_etc') self._reverse = ( 'pubchem_id', 'kegg_id', 'hmdb_id', 'lipidmaps_id', )
def get_edit(self): if not current_user.username or not current_user.admin: return redirect('/users/login') # load user to view: username = request.args.get('username') uid = request.args.get('uid') repo = get_repo(User) if username is not None: my_user = repo.find_user(username=username) elif uid is not None: my_user = repo.get(uid) else: my_user = current_user if not my_user: return "not found" return render_template('/users/edit.html', uinfo=my_user)
def import_db(self, autoclear: bool = False): repo: HMDBDataRepository = get_repo(HMDBData) if repo.count() > 0: print("HMDB Data is not empty. Truncate the table? Y/n:", end="") if autoclear or input().lower() == 'y': print("Clearing DB") repo.delete_all() else: print("Exited") return # parse XML file: context = ET.iterparse(self.path, events=("start", "end")) context = iter(context) ev_1, xroot = next(context) i = 0 for ev_2, xmeta in context: # Úgy még sosem volt, hogy valahogy ne lett volna me = parse_xml_recursive(context, _mapping=_mapping) if isinstance(me, str) or me is None: continue data: HMDBData = parse_hmdb(me) repo.create(data, commit=False) if i % 500 == 0: print(f"\rInserting... {i}", end="") i += 1 if i % 3000 == 0: repo.save() print(" Committed") repo.save() print(" Committed everything to DB") ding() ding() ding()
def __init__(self, dbconf): self.name = 'kegg' self.repo = get_repo(KeggData) self.conf = dbconf self._select = ( 'kegg_id', 'chebi_id', 'lipidmaps_id', 'names', 'formula', 'mass', 'monoisotopic_mass', #'comments' 'ref_etc') self._reverse = ( 'chebi_id', 'lipidmaps_id', #'pubchem_id' )
def __init__(self, dbconf): self.name = 'hmdb' self.repo = get_repo(HMDBData) self.conf = dbconf self.padding = 'HMDB' self._select = ('pubchem_id', 'chebi_id', 'kegg_id', 'hmdb_id', 'metlin_id', 'smiles', 'inchi', 'inchikey', 'formula', 'names', 'avg_mol_weight', 'monoisotopic_mol_weight', 'ref_etc') self._remap = { 'avg_mol_weight': 'mass', 'monoisotopic_mol_weight': 'monoisotopic_mass' } self._reverse = ( 'pubchem_id', 'kegg_id', 'chebi_id', )
def __init__(self, dbconf): self.name = 'pubchem' self.repo = get_repo(PubChemData) self.conf = dbconf self._select = ( 'pubchem_id', 'chebi_id', 'kegg_id', 'hmdb_id', 'smiles', 'inchi', 'inchikey', 'formula', 'names', 'mass', 'monoisotopic_mass', #'logp' 'ref_etc') self._remap = {'monoisotopic': 'monoisotopic_mass', 'hmdb': 'hmdb_id'} self._reverse = ('chebi_id', 'hmdb_id', 'kegg_id')
import requests from authlib.integrations.requests_client import OAuth2Auth from authlib.oauth2.rfc6749 import TokenMixin from authlib.oauth2.rfc6750 import BearerTokenValidator from authlib.integrations.flask_oauth2 import ResourceProtector from flask_login import LoginManager, current_user, login_user, logout_user, login_required from eme.data_access import get_repo from ..dal.user import User from ..dal.repository import UserRepository require_oauth = ResourceProtector() login_manager = LoginManager() user_repo: UserRepository = get_repo(User) conf: dict class DoorsCachedToken(TokenMixin): def __init__(self, access_token, user): self.access_token = access_token self.user = user def get_client_id(self): return conf['client_id'] def get_scope(self): return conf['scope'] def get_expires_in(self):
def init_search(app, conf): global _searches, _repo _searches = conf _repo = get_repo(SearchItem)
from eme.data_access import get_repo from sqlalchemy import and_, or_, distinct from core.dal.ctx import get_session from ..dal.entity import SearchItem from ..dal.repository import SearchItemRepository """ Add levensthein distance (EME?) https://towardsdatascience.com/fuzzy-matching-with-levenshtein-and-postgresql-ed66cad01c03 """ _searches: dict _repo: SearchItemRepository = get_repo(SearchItem) def init_search(app, conf): global _searches, _repo _searches = conf _repo = get_repo(SearchItem) def search(category: str, search_term: str, attrs: list = None): _search_strat: dict = _searches[category] if attrs is None: attrs = _search_strat.keys() is_distinct: bool = _search_strat['__distinct__'] limit: int = _search_strat.get('__limit__', None) attr_classes = {
import random import string from typing import Sequence from eme.data_access import get_repo from core.dal import MetaboliteView, Metabolite from core.discovery import resolve_single_id from core.metabolite import get_metabolites, view_to_db from modules.search import search, SearchItem _meta_repo = get_repo(Metabolite) _ENDPOINT = '/metabolite/{}' def search_metabolite(search_term, search_attr: list, discover: bool = True, cache: bool = True, verbose=True): if not isinstance(search_attr, (list, tuple, set)) and search_attr is not None: search_attr = [search_attr] result = search('metabolite', search_term, attrs=search_attr) if not result and discover: # search term is not cached. initiate discovery mv, resp = resolve_single_id(search_attr, search_term,
def __init__(self, server): self.server = server self.repo: UserRepository = get_repo(User) self.route = ''
def init_wsapp(app, wsconf): auth.init_ws(app, conf, get_repo(User)) app.load_groups({"Users": UsersGroup(app)}, conf=conf)
from typing import Sequence from eme.data_access import get_repo from core.dal import Metabolite, MetaboliteView, ChEBIData, HMDBData, KeggData, LipidMapsData, PubChemData, MetaboliteRepository from core.discovery import getdb, db_managers _repo: MetaboliteRepository = get_repo(Metabolite) def get_metabolite(meta_id) -> MetaboliteView: meta: Metabolite = _repo.get(meta_id) return to_view(meta) def get_metabolites(meta_ids) -> Sequence[MetaboliteView]: if not isinstance(meta_ids, (list, tuple, set)): raise Exception("please provide a list") metas = _repo.list(meta_ids) views = [] for meta in metas: views.append(to_view(meta)) return views def to_view(meta: Metabolite): """
def _safecheck(): if get_repo(User).count() > 20: raise Exception( "It seems like developer mode has been enabled on the production website!!" )
def init(app, conf): global user_repo, user_manager user_repo = get_repo(User) user_manager = UserManager(user_repo)