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)
