import json import logging from django.conf import settings as s from django.contrib.auth import get_user_model from django.http import JsonResponse, HttpResponse, HttpResponseNotAllowed, HttpResponseBadRequest from django.shortcuts import render, redirect from django.views.decorators.csrf import csrf_exempt from utilities.chem import FormatConverter, IndigoUtils from .logic import GroupManager, PackageManager, UserManager, SettingManager from .models import Package, GroupPackagePermission, Group, CompoundStructure, Compound, Reaction, Rule, Pathway, Node, \ EPModel, EnviFormer, MLRelativeReasoning, RuleBaseRelativeReasoning, Scenario, SimpleAmbitRule, APIToken, \ UserPackagePermission, Permission logger = logging.getLogger(__name__) def log_post_params(request): for k, v in request.POST.items(): logger.debug(f"{k}\t{v}") def get_base_context(request): current_user = _anonymous_or_real(request) ctx = { 'title': 'enviPath', 'meta': { 'version': '0.0.1', 'server_url': s.SERVER_URL, 'user': current_user, 'readable_packages': PackageManager.get_all_readable_packages(current_user, include_reviewed=True), 'writeable_packages': PackageManager.get_all_writeable_packages(current_user), 'available_groups': GroupManager.get_groups(current_user), 'available_settings': SettingManager.get_all_settings(current_user), 'enabled_features': [], 'debug': s.DEBUG, }, } return ctx def _anonymous_or_real(request): if request.user.is_authenticated and not request.user.is_anonymous: return request.user return get_user_model().objects.get(username='anonymous') def breadcrumbs(first_level_object=None, second_level_namespace=None, second_level_object=None): bread = [ {'Home': s.SERVER_URL}, {'Package': s.SERVER_URL + '/package'}, ] if first_level_object is not None: bread.append({first_level_object.name: first_level_object.url}) if second_level_namespace is not None: bread.append({f'{second_level_namespace}'.capitalize(): first_level_object.url + f'/{second_level_namespace}'}) if second_level_object is not None: bread.append({second_level_object.name: second_level_object.url}) return bread def index(request): current_user = _anonymous_or_real(request) context = get_base_context(request) context['title'] = 'enviPath - Home' context['meta']['current_package'] = context['meta']['user'].default_package if request.GET.get('getMLServerPath', False): return JsonResponse({"mlServerPath": s.SERVER_URL}) return render(request, 'index/index.html', context) def packages(request): current_user = _anonymous_or_real(request) if request.method == 'GET': context = get_base_context(request) context['title'] = 'enviPath - Packages' context['object_type'] = 'package' context['meta']['current_package'] = context['meta']['user'].default_package reviewed_package_qs = Package.objects.filter(reviewed=True) unreviewed_package_qs = PackageManager.get_all_readable_packages(current_user) context['reviewed_objects'] = reviewed_package_qs context['unreviewed_objects'] = unreviewed_package_qs return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': hidden = request.POST.get('hidden', None) if hidden is not None: pass else: package_name = request.POST.get('package-name') package_description = request.POST.get('package-description', s.DEFAULT_VALUES['description']) # group = GroupManager.get_group_by_url(request.user, request.POST.get('package-group')) created_package = PackageManager.create_package(current_user, package_name, package_description) return redirect(created_package.url) elif request.method == 'OPTIONS': response = HttpResponse() response['allow'] = ','.join(['GET', 'POST']) return response else: return HttpResponseNotAllowed(['GET', 'POST']) def compounds(request): if request.method == 'GET': context = get_base_context(request) context['title'] = 'enviPath - Compounds' context['object_type'] = 'compound' context['meta']['current_package'] = context['meta']['user'].default_package reviewed_compound_qs = Compound.objects.none() for p in PackageManager.get_reviewed_packages(): reviewed_compound_qs |= Compound.objects.filter(package=p) if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": True} for pw in reviewed_compound_qs ] }) context['reviewed_objects'] = reviewed_compound_qs.order_by('name') return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': # delegate to default package current_user = _anonymous_or_real(request) default_package = current_user.default_package return package_compounds(request, default_package.uuid) def rules(request): if request.method == 'GET': context = get_base_context(request) context['title'] = 'enviPath - Rules' context['object_type'] = 'rule' context['meta']['current_package'] = context['meta']['user'].default_package context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Rule': s.SERVER_URL + '/rule'}, ] reviewed_rule_qs = Rule.objects.none() for p in PackageManager.get_reviewed_packages(): reviewed_rule_qs |= Rule.objects.filter(package=p).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": True} for pw in reviewed_rule_qs ] }) context['reviewed_objects'] = reviewed_rule_qs return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': # delegate to default package current_user = _anonymous_or_real(request) default_package = current_user.default_package return package_rules(request, default_package.uuid) def reactions(request): if request.method == 'GET': context = get_base_context(request) context['title'] = 'enviPath - Reactions' context['object_type'] = 'reaction' context['meta']['current_package'] = context['meta']['user'].default_package context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Reaction': s.SERVER_URL + '/reaction'}, ] reviewed_reaction_qs = Reaction.objects.none() for p in PackageManager.get_reviewed_packages(): reviewed_reaction_qs |= Reaction.objects.filter(package=p).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": True} for pw in reviewed_reaction_qs ] }) context['reviewed_objects'] = reviewed_reaction_qs return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': # delegate to default package current_user = _anonymous_or_real(request) default_package = current_user.default_package return package_reactions(request, default_package.uuid) def pathways(request): if request.method == 'GET': context = get_base_context(request) context['title'] = 'enviPath - Pathways' context['object_type'] = 'pathway' context['meta']['current_package'] = context['meta']['user'].default_package context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Pathway': s.SERVER_URL + '/pathway'}, ] reviewed_pathway_qs = Pathway.objects.none() for p in PackageManager.get_reviewed_packages(): reviewed_pathway_qs |= Pathway.objects.filter(package=p).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": True} for pw in reviewed_pathway_qs ] }) context['reviewed_objects'] = reviewed_pathway_qs return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': # delegate to default package current_user = _anonymous_or_real(request) default_package = current_user.default_package return package_pathways(request, default_package.uuid) def scenarios(request): if request.method == 'GET': context = get_base_context(request) context['title'] = 'enviPath - Scenarios' context['object_type'] = 'scenario' context['meta']['current_package'] = context['meta']['user'].default_package context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Scenario': s.SERVER_URL + '/scenario'}, ] reviewed_scenario_qs = Scenario.objects.none() for p in PackageManager.get_reviewed_packages(): reviewed_scenario_qs |= Scenario.objects.filter(package=p).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": True} for pw in reviewed_scenario_qs ] }) context['reviewed_objects'] = reviewed_scenario_qs return render(request, 'collections/objects_list.html', context) # TODO # elif request.method == 'POST': # # delegate to default package # default_package = request.user.default_package # return package_scenarios(request, default_package.uuid) def models(request): if request.method == 'GET': context = get_base_context(request) context['title'] = 'enviPath - Models' context['object_type'] = 'model' context['meta']['current_package'] = context['meta']['user'].default_package context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Model': s.SERVER_URL + '/model'}, ] context['model_types'] = { 'ML Relative Reasoning': 'ml-relative-reasoning', 'Rule Based Relative Reasoning': 'rule-based-relative-reasoning', 'EnviFormer': 'enviformer', } for k, v in s.CLASSIFIER_PLUGINS.items(): context['model_types'][v.display()] = k reviewed_model_qs = EPModel.objects.none() for p in PackageManager.get_reviewed_packages(): reviewed_model_qs |= EPModel.objects.filter(package=p).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": True} for pw in reviewed_model_qs ] }) context['reviewed_objects'] = reviewed_model_qs return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': current_user = _anonymous_or_real(request) default_package = current_user.default_package return package_models(request, default_package.uuid) def search(request): if request.method == 'GET': context = get_base_context(request) context['title'] = 'enviPath - Search' context['object_type'] = 'model' context['meta']['current_package'] = context['meta']['user'].default_package context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Search': s.SERVER_URL + '/search'}, ] # TODO perm reviewed_package_qs = Package.objects.filter(reviewed=True) unreviewed_package_qs = Package.objects.filter(reviewed=False) context['reviewed_objects'] = reviewed_package_qs context['unreviewed_objects'] = unreviewed_package_qs return render(request, 'search.html', context) def package_models(request, package_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - Models' context['meta']['current_package'] = current_package context['object_type'] = 'model' context['breadcrumbs'] = breadcrumbs(current_package, 'model') reviewed_model_qs = EPModel.objects.none() unreviewed_model_qs = EPModel.objects.none() if current_package.reviewed: reviewed_model_qs = EPModel.objects.filter(package=current_package).order_by('name') else: unreviewed_model_qs = EPModel.objects.filter(package=current_package).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": current_package.reviewed} for pw in (reviewed_model_qs if current_package.reviewed else unreviewed_model_qs) ] }) context['reviewed_objects'] = reviewed_model_qs context['unreviewed_objects'] = unreviewed_model_qs context['model_types'] = { 'ML Relative Reasoning': 'ml-relative-reasoning', 'Rule Based Relative Reasoning': 'rule-based-relative-reasoning', 'EnviFormer': 'enviformer', } for k, v in s.CLASSIFIER_PLUGINS.items(): context['model_types'][v.display()] = k return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': name = request.POST.get('model-name') description = request.POST.get('model-description') model_type = request.POST.get('model-type') if model_type == 'enviformer': threshold = float(request.POST.get(f'{model_type}-threshold', 0.5)) mod = EnviFormer.create(current_package, name, description, threshold) elif model_type == 'ml-relative-reasoning': threshold = float(request.POST.get(f'{model_type}-threshold', 0.5)) fingerprinter = request.POST.get(f'{model_type}-fingerprinter') rule_packages = request.POST.getlist(f'{model_type}-rule-packages') data_packages = request.POST.getlist(f'{model_type}-data-packages') eval_packages = request.POST.getlist(f'{model_type}-evaluation-packages', []) # get Package objects from urls rule_package_objs = [PackageManager.get_package_by_url(current_user, p) for p in rule_packages] data_package_objs = [PackageManager.get_package_by_url(current_user, p) for p in data_packages] eval_packages_objs = [PackageManager.get_package_by_url(current_user, p) for p in eval_packages] mod = MLRelativeReasoning.create( current_package, name, description, rule_package_objs, data_package_objs, eval_packages_objs, threshold ) from .tasks import build_model build_model.delay(mod.pk) elif model_type == 'rule-base-relative-reasoning': mod = RuleBaseRelativeReasoning() mod.save() return redirect(mod.url) def package_model(request, package_uuid, model_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) current_model = EPModel.objects.get(package=current_package, uuid=model_uuid) if request.method == 'GET': if request.GET.get('classify', False): smiles = request.GET['smiles'] stand_smiles = FormatConverter.standardize(smiles) pred_res = current_model.predict(stand_smiles) res = [] for pr in pred_res: if len(pr) > 0: products = [] for prod_set in pr.product_sets: print(f"Checking {prod_set}") products.append(tuple([x for x in prod_set])) res.append({ 'products': list(set(products)), 'probability': pr.probability, 'btrule': {k: getattr(pr.rule, k) for k in ['url', 'name']} if pr.rule is not None else None }) return JsonResponse(res, safe=False) context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - {current_model.name}' context['meta']['current_package'] = current_package context['object_type'] = 'model' context['breadcrumbs'] = breadcrumbs(current_package, 'model', current_model) context['model'] = current_model return render(request, 'objects/model.html', context) if request.method == 'POST': if hidden := request.POST.get('hidden', None): if hidden == 'delete-model': current_model.delete() return redirect(current_package.url + '/model') else: return HttpResponseBadRequest() else: return HttpResponseBadRequest() # # new_compound_name = request.POST.get('compound-name') # new_compound_description = request.POST.get('compound-description') # # if new_compound_name: # current_compound.name = new_compound_name # # if new_compound_description: # current_compound.description = new_compound_description # # if any([new_compound_name, new_compound_description]): # current_compound.save() # return redirect(current_compound.url) # else: # return HttpResponseBadRequest() def package(request, package_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name}' context['meta']['current_package'] = current_package context['object_type'] = 'package' context['breadcrumbs'] = breadcrumbs(current_package) context['package'] = current_package # context['package_group'] = GroupPackagePermission.objects.filter(package=current_package, # permission=GroupPackagePermission.ALL) user_perms = UserPackagePermission.objects.filter(package=current_package) users = get_user_model().objects.exclude( id__in=UserPackagePermission.objects.filter(package=current_package).values_list('user_id', flat=True)) group_perms = GroupPackagePermission.objects.filter(package=current_package) groups = Group.objects.exclude( id__in=GroupPackagePermission.objects.filter(package=current_package).values_list('group_id', flat=True)) context['users'] = users context['groups'] = groups context['user_permissions'] = user_perms context['group_permissions'] = group_perms return render(request, 'objects/package.html', context) elif request.method == 'POST': if s.DEBUG: for k, v in request.POST.items(): print(k, v) if hidden := request.POST.get('hidden', None): if hidden == 'delete-package': print(current_package.delete()) return redirect(s.SERVER_URL + '/package') else: return HttpResponseBadRequest() new_package_name = request.POST.get('package-name') new_package_description = request.POST.get('package-description') grantee_url = request.POST.get('grantee') read = request.POST.get('read') == 'on' write = request.POST.get('write') == 'on' owner = request.POST.get('owner') == 'on' if new_package_name: current_package.name = new_package_name if new_package_description: current_package.description = new_package_description if any([new_package_name, new_package_description]): current_package.save() return redirect(current_package.url) elif any([grantee_url, read, write, owner]): if 'user' in grantee_url: grantee = UserManager.get_user_lp(grantee_url) else: grantee = GroupManager.get_group_lp(grantee_url) max_perm = None if read: max_perm = Permission.READ[0] if write: max_perm = Permission.WRITE[0] if owner: max_perm = Permission.ALL[0] PackageManager.update_permissions(current_user, current_package, grantee, max_perm) return redirect(current_package.url) else: return HttpResponseBadRequest() # https://envipath.org/package//compound def package_compounds(request, package_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - Compounds' context['meta']['current_package'] = current_package context['object_type'] = 'compound' context['breadcrumbs'] = breadcrumbs(current_package, 'compound') reviewed_compound_qs = Compound.objects.none() unreviewed_compound_qs = Compound.objects.none() if current_package.reviewed: reviewed_compound_qs = Compound.objects.filter(package=current_package).order_by('name') else: unreviewed_compound_qs = Compound.objects.filter(package=current_package).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": current_package.reviewed} for pw in (reviewed_compound_qs if current_package.reviewed else unreviewed_compound_qs) ] }) context['reviewed_objects'] = reviewed_compound_qs context['unreviewed_objects'] = unreviewed_compound_qs return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': compound_name = request.POST.get('compound-name') compound_smiles = request.POST.get('compound-smiles') compound_description = request.POST.get('compound-description') c = Compound.create(current_package, compound_smiles, compound_name, compound_description) return redirect(c.url) # https://envipath.org/package//compound/ def package_compound(request, package_uuid, compound_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) current_compound = Compound.objects.get(package=current_package, uuid=compound_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - {current_compound.name}' context['meta']['current_package'] = current_package context['object_type'] = 'compound' context['breadcrumbs'] = breadcrumbs(current_package, 'compound', current_compound) context['compound'] = current_compound return render(request, 'objects/compound.html', context) if request.method == 'POST': if hidden := request.POST.get('hidden', None): if hidden == 'delete-compound': current_compound.delete() return redirect(current_package.url + '/compound') else: return HttpResponseBadRequest() new_compound_name = request.POST.get('compound-name') new_compound_description = request.POST.get('compound-description') if new_compound_name: current_compound.name = new_compound_name if new_compound_description: current_compound.description = new_compound_description if any([new_compound_name, new_compound_description]): current_compound.save() return redirect(current_compound.url) else: return HttpResponseBadRequest() # https://envipath.org/package//compound//structure def package_compound_structures(request, package_uuid, compound_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) current_compound = Compound.objects.get(package=current_package, uuid=compound_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - {current_compound.name} - Structures' context['meta']['current_package'] = current_package context['object_type'] = 'structure' reviewed_compound_structure_qs = CompoundStructure.objects.none() unreviewed_compound_structure_qs = CompoundStructure.objects.none() if package.reviewed: reviewed_compound_structure_qs = current_compound.structures.order_by('name') else: unreviewed_compound_structure_qs = current_compound.structures.order_by('name') context['reviewed_objects'] = reviewed_compound_structure_qs context['unreviewed_objects'] = unreviewed_compound_structure_qs return render(request, 'collections/objects_list.html', context) # https://envipath.org/package//compound//structure/ def package_compound_structure(request, package_uuid, compound_uuid, structure_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) current_compound = Compound.objects.get(package=current_package, uuid=compound_uuid) current_structure = CompoundStructure.get(compound=current_compound, uuid=structure_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - {current_compound.name} - {current_structure.name}' context['meta']['current_package'] = current_package context['object_type'] = 'compound' context['compound_structure'] = current_structure return render(request, 'objects/compound_structure.html', context) # https://envipath.org/package//rule def package_rules(request, package_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - Rules' context['meta']['current_package'] = current_package context['object_type'] = 'rule' context['breadcrumbs'] = breadcrumbs(current_package, 'rule') reviewed_rule_qs = Rule.objects.none() unreviewed_rule_qs = Rule.objects.none() if current_package.reviewed: reviewed_rule_qs = Rule.objects.filter(package=current_package).order_by('name') else: unreviewed_rule_qs = Rule.objects.filter(package=current_package).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": current_package.reviewed} for pw in (reviewed_rule_qs if current_package.reviewed else unreviewed_rule_qs) ] }) context['reviewed_objects'] = reviewed_rule_qs context['unreviewed_objects'] = unreviewed_rule_qs return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': for k, v in request.POST.items(): print(k, v) # Generic params rule_name = request.POST.get('rule-name') rule_description = request.POST.get('rule-description') rule_type = request.POST.get('rule-type') params = {} # Obtain parameters as required by rule type if rule_type == 'SimpleAmbitRule': params['smirks'] = request.POST.get('rule-smirks') params['reactant_smarts'] = request.POST.get('rule-reactant-smarts') params['product_smarts'] = request.POST.get('rule-product-smarts') elif rule_type == 'SimpleRDKitRule': params['reaction_smarts'] = request.POST.get('rule-reaction-smarts') elif rule_type == 'ParallelRule': pass elif rule_type == 'SequentialRule': pass else: return HttpResponseBadRequest() r = Rule.create(current_package, rule_type, name=rule_name, description=rule_description, **params) return redirect(r.url) # https://envipath.org/package//rule/ def package_rule(request, package_uuid, rule_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) current_rule = Rule.objects.get(package=current_package, uuid=rule_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - {current_rule.name}' context['meta']['current_package'] = current_package context['object_type'] = 'rule' context['breadcrumbs'] = breadcrumbs(current_package, 'rule', current_rule) context['rule'] = current_rule if isinstance(current_rule, SimpleAmbitRule): return render(request, 'objects/simple_rule.html', context) else: # isinstance(current_rule, ParallelRule) or isinstance(current_rule, SequentialRule): return render(request, 'objects/composite_rule.html', context) if request.method == 'POST': if hidden := request.POST.get('hidden', None): if hidden == 'delete-rule': current_rule.delete() return redirect(current_package.url + '/rule') else: return HttpResponseBadRequest() # TODO update! # https://envipath.org/package//reaction def package_reactions(request, package_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - {current_package.name} - Reactions' context['meta']['current_package'] = current_package context['object_type'] = 'reaction' context['breadcrumbs'] = breadcrumbs(current_package, 'reaction') reviewed_reaction_qs = Reaction.objects.none() unreviewed_reaction_qs = Reaction.objects.none() if current_package.reviewed: reviewed_reaction_qs = Reaction.objects.filter(package=current_package).order_by('name') else: unreviewed_reaction_qs = Reaction.objects.filter(package=current_package).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": current_package.reviewed} for pw in (reviewed_reaction_qs if current_package.reviewed else unreviewed_reaction_qs) ] }) context['reviewed_objects'] = reviewed_reaction_qs context['unreviewed_objects'] = unreviewed_reaction_qs return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': reaction_name = request.POST.get('reaction-name') reaction_description = request.POST.get('reaction-description') reactions_smirks = request.POST.get('reaction-smirks') educts = reactions_smirks.split('>>')[0].split('.') products = reactions_smirks.split('>>')[1].split('.') r = Reaction.create(current_package, name=reaction_name, description=reaction_description, educts=educts, products=products) return redirect(r.url) # https://envipath.org/package//reaction/ def package_reaction(request, package_uuid, reaction_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) current_reaction = Reaction.objects.get(package=current_package, uuid=reaction_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - {current_reaction.name}' context['meta']['current_package'] = current_package context['object_type'] = 'reaction' context['breadcrumbs'] = breadcrumbs(current_package, 'reaction', current_reaction) context['reaction'] = current_reaction return render(request, 'objects/reaction.html', context) if request.method == 'POST': if hidden := request.POST.get('hidden', None): if hidden == 'delete-reaction': current_reaction.delete() return redirect(current_package.url + '/reaction') else: return HttpResponseBadRequest() new_reaction_name = request.POST.get('reaction-name') new_reaction_description = request.POST.get('reaction-description') if new_reaction_name: current_reaction.name = new_reaction_name if new_reaction_description: current_reaction.description = new_reaction_description if any([new_reaction_name, new_reaction_description]): current_reaction.save() return redirect(current_reaction.url) else: return HttpResponseBadRequest() # https://envipath.org/package//pathway def package_pathways(request, package_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - Pathways' context['meta']['current_package'] = current_package context['object_type'] = 'pathway' context['breadcrumbs'] = breadcrumbs(current_package, 'pathway') reviewed_pathway_qs = Pathway.objects.none() unreviewed_pathway_qs = Pathway.objects.none() if current_package.reviewed: reviewed_pathway_qs = Pathway.objects.filter(package=current_package).order_by('name') else: unreviewed_pathway_qs = Pathway.objects.filter(package=current_package).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": current_package.reviewed} for pw in (reviewed_pathway_qs if current_package.reviewed else unreviewed_pathway_qs) ] }) context['reviewed_objects'] = reviewed_pathway_qs context['unreviewed_objects'] = unreviewed_pathway_qs return render(request, 'collections/objects_list.html', context) if request.method == 'POST': log_post_params(request) name = request.POST.get('name', 'Pathway ' + str(Pathway.objects.filter(package=current_package).count())) description = request.POST.get('description', s.DEFAULT_VALUES['description']) pw_mode = request.POST.get('predict', 'predict') smiles = request.POST.get('smiles') if smiles is None or smiles == '': return HttpResponseBadRequest() stand_smiles = FormatConverter.standardize(smiles) pw = Pathway.create(current_package, name, description, stand_smiles) if pw_mode != 'build': pred_setting = current_user.prediction_settings() from .tasks import predict predict.delay(pw.pk, pred_setting.pk) return redirect(pw.url) # https://envipath.org/package//pathway/ def package_pathway(request, package_uuid, pathway_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) current_pathway = Pathway.objects.get(package=current_package, uuid=pathway_uuid) if request.method == 'GET': if request.GET.get("last_modified", False): return JsonResponse({'modified': current_pathway.modified.strftime('%Y-%m-%d %H:%M:%S')}) context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - {current_pathway.name}' context['meta']['current_package'] = current_package context['object_type'] = 'pathway' context['breadcrumbs'] = breadcrumbs(current_package, 'pathway', current_pathway) context['pathway'] = current_pathway context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Package': s.SERVER_URL + '/package'}, {current_package.name: current_package.url}, {'Pathway': current_package.url + '/pathway'}, {current_pathway.name: current_pathway.url}, ] return render(request, 'objects/pathway.html', context) # return render(request, 'pathway_playground2.html', context) if request.method == 'POST': if hidden := request.POST.get('hidden', None): if hidden == 'delete-pathway': current_pathway.delete() return redirect(current_package.url + '/pathway') else: return HttpResponseBadRequest() # # # # def package_relative_reasonings(request, package_id): # if request.method == 'GET': # pass # # # def package_relative_reasoning(request, package_id, relative_reasoning_id): # current_user = _anonymous_or_real(request) # # if request.method == 'GET': # pass # elif request.method == 'POST': # pass # # # # # # # # https://envipath.org/package//pathway//node # # def package_pathway_nodes(request, package_id, pathway_id): # # pass # # # # # https://envipath.org/package//pathway//node/ def package_pathway_node(request, package_uuid, pathway_uuid, node_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) current_pathway = Pathway.objects.get(package=current_package, uuid=pathway_uuid) current_node = Node.objects.get(pathway=current_pathway, uuid=node_uuid) if request.method == 'GET': is_image_request = request.GET.get('image') if is_image_request: if is_image_request == 'svg': svg_data = current_node.as_svg return HttpResponse(svg_data, content_type="image/svg+xml") # # # # # # # https://envipath.org/package//pathway//edge # # def package_pathway_edges(request, package_id, pathway_id): # # pass # # # # # # # https://envipath.org/package//pathway//edge/ # # def package_pathway_edge(request, package_id, pathway_id, edge_id): # # pass # # # # # https://envipath.org/package//scenario def package_scenarios(request, package_uuid): current_user = _anonymous_or_real(request) current_package = PackageManager.get_package_by_id(current_user, package_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_package.name} - Scenarios' context['meta']['current_package'] = current_package context['object_type'] = 'scenario' context['breadcrumbs'] = breadcrumbs(current_package, 'pathway') reviewed_scenario_qs = Scenario.objects.none() unreviewed_scenario_qs = Scenario.objects.none() if current_package.reviewed: reviewed_scenario_qs = Scenario.objects.filter(package=current_package).order_by('name') else: unreviewed_scenario_qs = Scenario.objects.filter(package=current_package).order_by('name') if request.GET.get('all'): return JsonResponse({ "objects": [ {"name": pw.name, "url": pw.url, "reviewed": current_package.reviewed} for pw in (reviewed_scenario_qs if current_package.reviewed else unreviewed_scenario_qs) ] }) context['reviewed_objects'] = reviewed_scenario_qs context['unreviewed_objects'] = unreviewed_scenario_qs return render(request, 'collections/objects_list.html', context) # https://envipath.org/package//scenario/ def package_scenario(request, package_uuid, scenario_uuid): pass ### END UNTESTED ############## # User/Group # ############## def users(request): if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - Users' context['meta']['current_package'] = context['meta']['user'].default_package context['object_type'] = 'user' context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'User': s.SERVER_URL + '/user'}, ] context['objects'] = get_user_model().objects.all() return render(request, 'collections/objects_list.html', context) if request.method == 'POST': is_login = bool(request.POST.get('login', False)) is_register = bool(request.POST.get('register', False)) if is_login: from django.contrib.auth import authenticate from django.contrib.auth import login username = request.POST.get('username') password = request.POST.get('password') # Get email for username try: email = get_user_model().objects.get(username=username).email except get_user_model().DoesNotExists: return HttpResponseBadRequest() user = authenticate(username=email, password=password) if user is not None: login(request, user) return redirect(s.SERVER_URL) else: return HttpResponseBadRequest() elif is_register: username = request.POST.get('username') email = request.POST.get('email') password = request.POST.get('password') rpassword = request.POST.get('rpassword') if password != rpassword: pass u = UserManager.create_user(username, email, password) return redirect(s.SERVER_URL) def user(request, user_uuid): current_user = _anonymous_or_real(request) if request.method == 'GET': # Check if current user is the one matching to the url if str(current_user.uuid) != user_uuid and not current_user.is_superuser: return HttpResponseBadRequest() context = get_base_context(request) context['title'] = f'enviPath - User' context['object_type'] = 'user' context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'User': s.SERVER_URL + '/user'}, {current_user.username: current_user.url} ] context['user'] = current_user model_qs = EPModel.objects.none() for p in PackageManager.get_all_readable_packages(current_user, include_reviewed=True): model_qs |= p.models context['models'] = model_qs context['tokens'] = APIToken.objects.filter(user=current_user) return render(request, 'objects/user.html', context) elif request.method == 'POST': is_hidden_method = bool(request.POST.get('hidden', False)) if is_hidden_method and request.POST['hidden'] == 'request-api-token': name = request.POST.get('name', 'No Name') valid_for = min(max(int(request.POST.get('valid-for', 90)), 1), 90) token, raw_token = APIToken.create_token(request.user, name=name, valid_for=valid_for) return JsonResponse({"raw_token": raw_token, 'token': {'id': token.id, 'name': token.name}}) if is_hidden_method and request.POST['hidden'] == 'delete': token_id = request.POST.get('token-id') if token_id is None: return HttpResponseBadRequest("Token ID missing!") try: APIToken.objects.get(user=current_user, id=token_id).delete() except APIToken.DoesNotExist: return HttpResponseBadRequest("User and Token ID combination invalid!") return HttpResponse("success") is_logout = bool(request.POST.get('logout', False)) if is_logout: from django.contrib.auth import logout logout(request) return redirect(s.SERVER_URL) prediction_model_pk = request.POST.get('model') prediction_threshold = request.POST.get('threshold') prediction_max_nodes = request.POST.get('max_nodes') prediction_max_depth = request.POST.get('max_depth') if all([prediction_model_pk, prediction_threshold, prediction_max_nodes, prediction_max_depth]): # validate input.. mod = EPModel.objects.get(id=prediction_model_pk) if not PackageManager.readable(current_user, mod.package): return HttpResponseBadRequest() threshold = float(prediction_threshold) if threshold < 0 or threshold > 1: return HttpResponseBadRequest() max_nodes = min(max(int(prediction_max_nodes), 1), 50) max_depth = min(max(int(prediction_max_depth), 1), 8) setting = { 'model': mod, 'model_parameters': { 'threshold': threshold }, 'truncator': { 'max_nodes': max_nodes, 'max_depth': max_depth, } } print(setting) return HttpResponseBadRequest() def groups(request): current_user = _anonymous_or_real(request) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - Groups' context['meta']['current_package'] = context['meta']['user'].default_package context['object_type'] = 'group' context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Group': s.SERVER_URL + '/group'}, ] context['objects'] = Group.objects.all() return render(request, 'collections/objects_list.html', context) elif request.method == 'POST': group_name = request.POST.get('group-name') group_description = request.POST.get('group-description', s.DEFAULT_VALUES['description']) g = GroupManager.create_group(current_user, group_name, group_description) return redirect(g.url) def group(request, group_uuid): current_user = _anonymous_or_real(request) current_group = GroupManager.get_group_by_id(current_user, group_uuid) if request.method == 'GET': context = get_base_context(request) context['title'] = f'enviPath - {current_group.name}' context['object_type'] = 'group' context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Group': s.SERVER_URL + '/group'}, {current_group.name: current_group.url} ] context['group'] = current_group # TODO use managers context['users'] = get_user_model().objects.exclude(id__in=current_group.user_member.all()) context['groups'] = Group.objects.exclude(id__in=current_group.group_member.all()).exclude(id=current_group.pk) context['packages'] = Package.objects.filter(id__in=GroupPackagePermission.objects.filter(group=current_group).values('package').distinct()) return render(request, 'objects/group.html', context) elif request.method == 'POST': if s.DEBUG: for k, v in request.POST.items(): print(k, v) if hidden := request.POST.get('hidden', None): if hidden == 'delete-group': current_group.delete() return redirect(s.SERVER_URL + '/group') else: return HttpResponseBadRequest() member_url = request.POST.get('member') action = request.POST.get('action') if all([member_url, action]) and action in ['add', 'remove']: if 'user' in member_url: member = UserManager.get_user_lp(member_url) else: member = GroupManager.get_group_lp(member_url) GroupManager.update_members(current_user, current_group, member, action) return redirect(current_group.url) def settings(request): current_user = _anonymous_or_real(request) context = get_base_context(request) if request.method == 'GET': context['object_type'] = 'setting' # Even if settings are aready in "meta", for consistency add it on root level context['settings'] = SettingManager.get_all_settings(current_user) context['breadcrumbs'] = [ {'Home': s.SERVER_URL}, {'Group': s.SERVER_URL + '/setting'}, ] return elif request.method == 'POST': if s.DEBUG: for k, v in request.POST.items(): logger.info("Parameters received:") logger.info(f"{k}\t{v}") name = request.POST.get('prediction-setting-name') description = request.POST.get('prediction-setting-description') new_default = request.POST.get('prediction-setting-new-default', 'off') == 'on' max_nodes = min(max(int(request.POST.get('prediction-setting-max-nodes', 1)), s.DEFAULT_MAX_NUMBER_OF_NODES), s.DEFAULT_MAX_NUMBER_OF_NODES) max_depth = min(max(int(request.POST.get('prediction-setting-max-depth', 1)), s.DEFAULT_MAX_DEPTH), s.DEFAULT_MAX_DEPTH) tp_gen_method = request.POST.get('tp-generation-method') params = {} if tp_gen_method == 'model-based-prediction-setting': model_url = request.POST.get('model-based-prediction-setting-model') model_uuid = model_url.split('/')[-1] params['model'] = EPModel.objects.get(uuid=model_uuid) params['model_threshold'] = request.POST.get('model-based-prediction-setting-threshold', s.DEFAULT_MODEL_THRESHOLD) if not PackageManager.readable(current_user, params['model'].package): raise ValueError("") elif tp_gen_method == 'rule-based-prediction-setting': rule_packages = request.POST.getlist('rule-based-prediction-setting-packages') params['rule_packages'] = [PackageManager.get_package_by_url(current_user, p) for p in rule_packages] else: raise ValueError("") created_setting = SettingManager.create_setting(current_user, name=name, description=description, max_nodes=max_nodes, max_depth=max_depth, **params) if new_default: current_user.default_setting = created_setting current_user.save() return HttpResponse("Success!") def setting(request, setting_uuid): pass ########### # KETCHER # ########### def indigo(request): from indigo import Indigo return JsonResponse({'Indigo': {'version': Indigo().version()}}) @csrf_exempt def aromatize(request): if request.method == 'POST': data = json.loads(request.body) mol_data = data.get('struct') aromatized = IndigoUtils.aromatize(mol_data, False) return JsonResponse({"struct": aromatized}) else: return HttpResponseBadRequest() @csrf_exempt def dearomatize(request): if request.method == 'POST': data = json.loads(request.body) mol_data = data.get('struct') dearomatized = IndigoUtils.dearomatize(mol_data, False) return JsonResponse({"struct": dearomatized}) else: return HttpResponseBadRequest() @csrf_exempt def layout(request): if request.method == 'POST': data = json.loads(request.body) mol_data = data.get('struct') lay = IndigoUtils.layout(mol_data) return JsonResponse({"struct": lay}) else: return HttpResponseBadRequest() ########################## # Generic/Non-Persistent # ########################## def depict(request): if smiles := request.GET.get('smiles'): return HttpResponse(IndigoUtils.mol_to_svg(smiles), content_type='image/svg+xml')