def test_divide_muts_by_sites(self):
from views.network import divide_muts_by_sites
# check if null case works
divide_muts_by_sites([], [])
# one site
s_1 = Site(position=1)
muts_by_sites = divide_muts_by_sites([], [s_1])
assert muts_by_sites[s_1] == []
# full test
s_2 = Site(position=10)
s_3 = Site(position=20)
muts_by_pos = {
pos: [Mutation(position=pos)]
for pos in (1, 2, 8, 14, 16, 30)
}
muts_by_pos[16].append(Mutation(position=16))
def get_muts_from_pos(*positions):
lists = [muts_by_pos[p] for p in positions]
return [mut for mut_list in lists for mut in mut_list]
muts_by_sites = divide_muts_by_sites([
mut for muts_on_pos_x in muts_by_pos.values()
for mut in muts_on_pos_x
], [s_1, s_2, s_3])
assert muts_by_sites[s_1] == get_muts_from_pos(1, 2, 8)
assert muts_by_sites[s_2] == get_muts_from_pos(8, 14, 16)
assert muts_by_sites[s_3] == get_muts_from_pos(14, 16)
def test_sites(self):
p = Protein(**test_protein_data())
sites = [
Site(position=3, residue='R', type='phosphorylation'),
Site(position=4, residue='T', type='methylation')
]
db.session.add(p)
p.sites = sites
response = self.client.get('/protein/sites/NM_000123')
assert response.status_code == 200
assert response.content_type == 'application/json'
assert len(response.json) == 2
phospo_site_repr = None
for site_repr in response.json:
if site_repr['type'] == 'phosphorylation':
phospo_site_repr = site_repr
assert phospo_site_repr
def create_network():
p = create_test_protein()
cancer = Cancer(name='Ovarian', code='OV')
known_interactor_of_x = create_test_kinase('Kinase Y', 'NM_0009')
kinase_mutation = Mutation(position=1,
alt='T',
meta_MC3=[MC3Mutation(cancer=cancer)])
known_interactor_of_x.protein.mutations = [kinase_mutation]
drug = Drug(
name='Drug targeting ' + known_interactor_of_x.name,
drug_bank_id='DB01',
target_genes=[known_interactor_of_x.protein.gene],
# by default only approved drugs are shown
groups={DrugGroup(name='approved')})
group = KinaseGroup(name='Group of kinases', )
s = Site(position=1,
type='phosphorylation',
residue='T',
kinases=[known_interactor_of_x],
kinase_groups=[group])
s2 = Site(position=2,
type='phosphorylation',
residue='R',
kinase_groups=[group])
p.sites = [s, s2]
predicted_interactor = create_test_kinase('Kinase Z', 'NM_0002')
protein_mutation = Mutation(position=2,
alt='T',
meta_MC3=[MC3Mutation(cancer=cancer)],
meta_MIMP=[
MIMPMutation(
pwm=known_interactor_of_x.name,
effect='loss',
site=s,
probability=0.1,
position_in_motif=1),
MIMPMutation(pwm=predicted_interactor.name,
effect='gain',
site=s,
probability=0.1,
position_in_motif=1)
])
p.mutations = [protein_mutation]
db.session.add_all([p, drug, predicted_interactor])
db.session.commit()
# a new cancer was added, reload is necessary (this should not happen during normal app usage)
from website.views.filters import cached_queries
cached_queries.reload()
def test_gather_residues(self):
methylation = SiteType(name='methylation')
p = Protein(refseq='NM_007', id=1, sequence='ABCD')
sites = [
Site(position=2, types={methylation}, protein=p), # default -> 'B'
Site(position=4, types={methylation}, residue='D'),
]
db.session.add_all(sites)
db.session.commit()
assert methylation.find_modified_residues() == {'B', 'D'}
def test_impact_on_ptm(self):
mutations = [Mutation(position=61)]
protein = Protein(refseq='NM_00001', mutations=mutations)
db.session.add(protein)
protein.sites = [
Site(position=61),
Site(position=54),
Site(position=51)
]
mutation = mutations[0]
assert mutation.impact_on_ptm() == 'direct'
def test_types(self):
methylation = SiteType(name='methylation')
p = Protein(refseq='NM_007', id=1, sequence='ABCD')
db.session.add(p)
site = Site(position=2, types={methylation}, residue='B', protein=p)
db.session.add(site)
db.session.commit()
query = Protein.query
assert query.filter(Protein.sites.any(
Site.types.contains(methylation))).one()
assert not query.filter(
Protein.sites.any(~Site.types.contains(methylation))).all()
assert Site.query.filter(Site.types.contains(methylation)).count() == 1
assert not Site.query.filter(~Site.types.contains(methylation)).all()
phosphorylation = SiteType(name='phosphorylation')
assert not query.filter(
Protein.sites.any(Site.types.contains(phosphorylation))).all()
assert query.filter(
Protein.sites.any(~Site.types.contains(phosphorylation))).one()
assert Site.query.filter(
Site.types.contains(phosphorylation)).count() == 0
def purify_html(request):
"""
过滤掉多余css,修正图片一些属性,替换超链接
:param request:
:return:
"""
html = request.GET.get('html', None)
base_url = request.GET.get('baseUrl', None)
css_path = request.GET.get('cssPath', None)
# 若果domain已经在数据库了就找到，没有就新建
domain_name = get_top_domain(base_url)
site_set = Site.objects.filter(domain_name=domain_name)
if site_set.exists():
s = site_set[0]
else:
s = Site()
s.domain_name = domain_name
# 保存二级页面的主要显示区域的css
if css_path.strip():
if not s.second:
second = SecondModifications()
second.css_path = css_path.strip()
second.save()
s.second = second
else:
second = s.second
second.css_path = css_path.strip()
second.save()
s.save()
res = purify(html, base_url)
if not res:
return HttpResponse(status=404)
return HttpResponse(res)
def siteconfig(request):
if request.method == 'GET':
return render_to_response('admin/siteconfig.html')
if request.method == 'POST':
sitename = request.POST.get('sitename')
keywords = request.POST.get('keywords')
descriptions = request.POST.get('descriptions')
copyrightinfo = request.POST.get('copyrightinfo')
form = PictureForm(request.POST, request.FILES)
if form.is_valid():
if 'login' and 'banner' in request.FILES:
login = request.FILES["login"]
banner = request.FILES["banner"]
else:
login = None
banner = None
parser = ImageFile.Parser()
for chunk in login.chunks() and banner.chunks():
parser.feed(chunk)
site = Site()
site.sitename = sitename
site.keywords = keywords
site.descriptions = descriptions
site.login = login
site.banner = banner
site.copyrightinfo = copyrightinfo
site.save()
return render_to_response('admin/siteconfig.html')
def add_site():
error = None
if request.method == 'POST':
title = request.form.get('title', '')
website = request.form.get('url', '').strip()
description = request.form.get('description', '')
source_url = request.form.get('source_url', '')
tags_names = request.form.get('tags', '').split(',')
tags_names = filter(lambda s: s, [tag.strip() for tag in tags_names])
if not website:
error = 'Site URL is required!'
else:
site = Site.query.filter_by(website=website).first()
if site is None:
# Add site info to db
site = Site(title=title,
website=website,
description=description,
source_url=source_url,
submitted_by=current_user)
for tag in map(get_or_create_tag, tags_names):
site.tags.append(tag)
db.session.add(site)
db.session.commit()
flash('Site submitted successfully!')
else:
flash('This site already submitted by someone!')
return redirect(url_for('show_site', site_id=site.id))
return render_template('add_site.html', error=error)
def list_site_availability(camp_area, start_date, end_date, equipment_type):
"""
Retrieve the Availability for all Sites in a Camp Area which can host the selected Equipment within a date range
:param camp_area:
:param start_date:
:param end_date:
:param equipment_type:
:return:
"""
data = {
'mapId':camp_area.map_id,
'bookingCategoryId':0,
'startDate':start_date.isoformat(),
'endDate':end_date.isoformat(),
'isReserving':True,
'getDailyAvailability':True,
'partySize':1,
'equipmentId':equipment_type,
'subEquipmentId':equipment_type,
'generateBreadcrumbs':False,
}
results = post_json('MAPDATA', data)
sites_availability = {}
for entry in results['resourcesOnMap']:
site = Site(entry['resourceId'], entry['localizedValues'][0]['name'],entry['localizedValues'][0]['description'])
allowed_equipment = [Equipment(e['item1'],e['item2'], None) for e in entry['allowedEquipment']]
availability = [
SiteAvailability(site, e['availability'], allowed_equipment)
for e in results['resourceAvailabilityMap'][str(site.resource_id)]
]
sites_availability[site] = availability
return OrderedDict(sorted(sites_availability.items(), key=lambda sa: sa[0].name.zfill(3)))
def test_sites(self):
mutations = [Mutation(position=x) for x in (0, 5, 12, 57)]
protein = Protein(refseq='NM_00002',
mutations=mutations,
sites=[Site(position=x) for x in (10, 14, 15, 57)])
db.session.add(protein)
db.session.commit()
# ==test_find_closest_sites==
# for mutation at position 0 there is no closest site;
# for mutation at position 5 there should be 1 closest site
expected_closest_sites = dict(zip(mutations, [0, 1, 2, 1]))
for mutation, expected_sites_cnt in expected_closest_sites.items():
sites_found = mutation.find_closest_sites()
assert len(sites_found) == expected_sites_cnt
# ==test_get_affected_ptm_sites==
expected_affected_sites = dict(zip(mutations, [0, 1, 3, 1]))
for mutation, expected_sites_cnt in expected_affected_sites.items():
sites_found = mutation.get_affected_ptm_sites()
assert len(sites_found) == expected_sites_cnt
def rename_usergroup_site():
for group in UserGroup.all():
site = Site(name=group.name.replace(' - User Group', ''), users=group.users, admins=group.admins)
site.put()
for style in group.style_set:
style.site = site
style.put()
def test_prepare_tracks():
protein = Protein(refseq='NM_01',
sequence='123456789',
sites=[Site(position=4)])
sequence_track = SequenceTrack(protein)
site = sequence_track.subtracks[0].elements[0]
assert site.start >= 0
def list_sites(camp_area, start_date, end_date, equipment_type):
"""
Retrieve Sites within a Camp Area which can host the selected Equipment within a date range
:param camp_area:
:param start_date:
:param end_date:
:param equipment_type:
:return:
"""
data = {
'mapId': camp_area.map_id,
'bookingCategoryId': 0,
'startDate': start_date.isoformat(),
'endDate': end_date.isoformat(),
'isReserving': True,
'getDailyAvailability': True,
'partySize': 1,
'equipmentId': equipment_type,
'subEquipmentId': equipment_type,
'generateBreadcrumbs': False,
}
results = post_json('MAPDATA', data)
sites = []
for entry in results['resourcesOnMap']:
sites.append(
Site(entry['resourceId'], entry['localizedValues'][0]['name'],
entry['localizedValues'][0]['description']))
sites.sort(key=lambda site: site.name.zfill(3))
return sites
def insert_site(self, domain, robots, url, session):
sitemaps = list(robots.sitemaps) # get sitemaps
if domain not in self.scraped_sites:
site = Site(domain=domain,
robots_content=str(robots),
sitemap_content=sitemaps)
session.add(site)
session.commit()
site_id = site.id
self.scraped_sites.add(domain)
page = Page(site_id=site_id, page_type_code='FRONTIER', url=url)
session.add(page)
session.commit()
page_id = page.id
self.scraped_pages.add(url)
if len(sitemaps) > 0:
r = requests.get(sitemaps[0])
root = etree.fromstring(r.content)
for sitemap in root:
children = sitemap.getchildren()
candidate = children[
0].text # if sitemap link is not in frontier, add to it
if candidate not in self.scraped_pages:
self.frontier.put(candidate)
self.insert_page(site_id, candidate, page_id, session)
else:
site = session.query(Site).filter(Site.domain == domain).first()
site_id = site.id
return site_id
def create_test_models():
protein = Protein(refseq='NM_0001',
gene=Gene(name='SOMEGENE'),
sequence='ABCD')
mutation = Mutation(protein=protein, position=1, alt='E')
protein.gene.preferred_isoform = protein
MC3Mutation(mutation=mutation,
cancer=Cancer(code='CAN'),
samples='Sample A,Sample B',
count=2)
InheritedMutation(mutation=mutation,
clin_data=[
ClinicalData(disease=Disease(name='Some disease'),
sig_code=5),
ClinicalData(disease=Disease(name='Other disease'),
sig_code=2)
])
protein_kinase = Protein(refseq='NM_0002',
gene=Gene(name='OTHERGENE'),
sequence='ABCD')
kinase = Kinase(name='Kinase name', protein=protein_kinase)
site = Site(protein=protein,
position=1,
residue='A',
kinases={kinase},
pmid={1, 2},
types={SiteType(name='glycosylation')})
protein.sites = [site]
return locals()
def sites():
root_domain = app.config.get("DOMAIN_ROOT")
port = app.config.get("PORT", None)
if request.method == "POST":
domain = request.form["domain"]
name = request.form["name"]
if domain and name:
site = Site()
site.name = name.strip()
site.domain = domain.strip()
conflicting_site = Site.objects.filter(domain=site.domain).first()
if not conflicting_site:
site.description = _(
"<h1>Introductory text</h1><p>This should "
"contain simple help about what is changeable and how."
"</p>")
site.save()
url = "//%s" % site.domain
if root_domain:
url += ".%s" % root_domain
if port:
url += ":%d" % port
return redirect(url)
return redirect(url_for("sites"))
if root_domain == g.site.domain:
sites = Site.objects.all()
else:
sites = Site.objects.filter(domain__endswith=g.site.domain)
return render_template("sites.html",
sites=sites,
root_domain=root_domain,
port=port)
def add_site(self):
self.template_path = 'site_add.html'
# get the site code
site_code = self.request.get('site_code').strip()
self.vars['site_code'] = site_code
# return if there is no site_code, or we are not a post
if (not site_code) or self.request.method != 'POST':
return
# check that the site_code is valid
if not Site.is_code_valid(site_code):
self.vars['site_code_error'] = "site code is not valid"
return
# check that the site_code is valid
if Site.is_code_taken(site_code):
self.vars['site_code_error'] = "site code already exists"
return
# ok to create
site = Site(site_code=site_code, owner=self.person)
site.put()
# create the first shared secret
SharedSecret.new_for_site(site)
self.redirect('/site/' + site_code)
def _create_example_site(user):
site = Site(
name='Example Site',
owner=user,
users=[user],
admins=[user],
example=True,
)
site.put()
for v in [4, 5]:
name = 'Html%d Example' % v
style = Style(site=site, name=name)
style.put()
rev = StyleRevision(parent=style, rev=0)
rev.put()
rev.update(render_template('examples/blog-html%d.css' % v))
style.published_rev = rev
rev = StyleRevision(parent=style, rev=1)
rev.put()
rev.update(render_template('examples/blog-html%d-preview.css' % v))
style.preview_rev = rev
style.put()
page = Page(site=site,
name=name,
url=url_for('example%d' % v, page_key=0, _external=True),
_styles=[style.key()])
page.put()
page.url = url_for('example%d' % v,
page_key=page.key(),
_external=True)
page.put()
page.queue_refresh()
def new_site():
user = users.get_current_user()
form = PageForm(request.form)
if request.method == 'POST':
if form.validate():
site = Site(
name=form.name.data,
owner=user,
users=[user],
admins=[user],
)
site.put()
page = Page.new_page(site, form.name.data, form.url.data)
new_url = url_for('editor', page_id=page.key().id())
if request.is_xhr:
return jsonify(dict(type='success', redirect=new_url))
else:
return redirect(new_url)
elif request.is_xhr:
return jsonify(
dict(type='error',
errors=render_template('form_errors.html', form=form)))
if request.is_xhr:
return render_template('site_creator.html', form=form)
return render_template('new_site.html', form=form)
def test_has_sites_in_range(self):
mutation_position = 100
sites_result = {
(93, 107): True,
(92, 108): False,
(100,): True,
tuple(): False,
(90,): False,
(110,): False,
(94, 95, 96, 97, 98, 99): True,
(101, 102, 103, 104, 105, 106): True,
(93,): True,
(107,): True
}
for sites_positions, expected_result in sites_result.items():
protein = Protein(
sites=[
Site(position=pos)
for pos in sites_positions
]
)
result = protein.has_sites_in_range(mutation_position - 7, mutation_position + 7)
assert result == expected_result
def load_sites(filename):
with open(filename) as json_file:
data = json.load(json_file)
for item in data["sites"]:
adder = DBModelAdder()
adder.start()
name = item["name"]
url = item["url"]
meta = item["meta"]
chat = item["chat"]
api_name = item["api_name"]
launch_date = datetime.utcfromtimestamp(int(item["launch_date"]))
language = item["language"]
site = Site.by_api_name(api_name)
if site is not None:
site.name = name
site.url = url
site.meta = meta
site.chat = chat
else:
site = Site(name, url, meta, chat, api_name, launch_date,
language)
adder.add(site)
adder.done()
def _tx():
site = Site.get_by_key_name(loc["id"])
if site is None:
site = Site(key_name=loc["id"])
site.location = GeoPt(lat = loc["location"][0], lon = loc["location"][1])
site.name = loc["name"]
site.region = loc["region"]
site.save()
def test_consistency(self):
p = Protein(refseq='NM_007', id=1, sequence='ABCD')
db.session.add(p)
# matching residue (note: for sites, positions are 1-based)
assert Site(position=2, type='methylation', residue='B', protein=p)
# mismatched residue
with pytest.raises(ValidationError):
Site(position=3, type='methylation', residue='B', protein=p)
# no residue and position in range
assert Site(position=2, protein=p)
# no residue and position outside of range
with pytest.raises(ValidationError):
Site(position=5, protein=p)
with pytest.raises(ValidationError):
Site(position=-5, protein=p)
def test_search_mutations(self):
s = Site(position=13, types={SiteType(name='methylation')})
p = Protein(refseq='NM_007', id=7, sites=[s], sequence='XXXXXXXXXXXXV')
m_in_site = Mutation(protein=p, position=13, alt='V')
m_out_site = Mutation(protein=p, position=50, alt='K')
db.session.add(p)
# points to the same location as first record in VCF_FILE_CONTENT
test_query = 'chr20 14370 G A'
from database import bdb
# map the first genomic mutation from VCF_FILE_CONTENT
# to some (mocked) protein mutation
bdb.add_genomic_mut('20', 14370, 'G', 'A', m_in_site, is_ptm=True)
#
# basic test - is appropriate mutation in results?
#
response = self.search_mutations(mutations=test_query)
assert response.status_code == 200
# this mutation is exactly at a PTM site and should be included in results
assert '<td>{0}</td>'.format(m_in_site.alt).encode() in response.data
# this mutation lies outside of a PTM site - be default should be filtered out
assert '<td>{0}</td>'.format(m_out_site.alt).encode() not in response.data
#
# count test - is mutation for this query annotated as shown twice?
#
response = self.search_mutations(
mutations='{0}\n{0}'.format(test_query)
)
assert response.status_code == 200
assert b'<td>2</td>' in response.data
#
# VCF file test
#
response = self.client.post(
'/search/mutations',
content_type='multipart/form-data',
data={
'vcf-file': (BytesIO(VCF_FILE_CONTENT), 'exemplar_vcf.vcf')
}
)
assert response.status_code == 200
assert b'NM_007' in response.data
def site_page(code):
# Find a site that matches this code
site = Site(code)
# Load weather data for this site. Data is not preloaded to avoid
# downloading entire batch of Environment Canada data on first run.
template = jinja_env.get_template("site.html")
return template.render(
site = site,
home = home(),
timetext = site.load_weather()[2],
)
def test_default_residue(self):
p = Protein(refseq='NM_007', id=1, sequence='ABCD')
methylation = SiteType(name='methylation')
# note: for sites, positions are 1-based)
site = Site(position=2, types={methylation}, protein=p)
db.session.add(p)
db.session.commit()
assert site.residue == 'B'
def test_train_model(self):
phosphorylation = SiteType(name='phosphorylation')
# non-phosphorylated serine residues are needed to generate negative sites
p = Protein(refseq='NM_007',
sequence='--------SLPA-----------SVIT-------')
g = Gene(isoforms=[p], preferred_isoform=p)
db.session.add(g)
# phosphorylated, with sites
p = Protein(refseq='NM_001',
sequence='--------SPAK-----------SPAR-------')
g = Gene(isoforms=[p], preferred_isoform=p)
db.session.add(g)
k = Kinase(name='CDK1', is_involved_in={phosphorylation})
for pos in [9, 24]:
s = Site(position=pos,
types={phosphorylation},
residue='S',
protein=p,
kinases={k})
db.session.add(s)
db.session.commit()
with TemporaryDirectory() as temp_dir:
model = train_model(phosphorylation,
sequences_dir=temp_dir,
sampling_n=2,
threshold=2)
# the model should have one set of params - for CDK1 kinase
assert len(model) == 1
cdk_params = model.rx2('CDK1')
pwm = cdk_params.rx2('pwm')
# and the position-specific weight matrix should be created
assert pwm
# the very detailed testing should be performed by rMIMP,
# but why not test the basics?
weights_of_central_aa = {
aa: value
for aa, value in zip(pwm.rownames, pwm.rx(True, 8))
}
assert weights_of_central_aa['S'] == max(
weights_of_central_aa.values())
def create_edit_site(form, site_id=None, user=None):
if site_id:
site = SiteInstanceResource()._get(site_id=site_id)
else:
site = Site()
site.sitename = form.cleaned_data['sitename']
site.url = form.cleaned_data['url']
site.auto_test_mode = int(form.cleaned_data['auto_test_mode'])
site.save()
if user:
user = UserProfileInstanceResource()._get(user=user)
user.hassites.add(site)
user.save()
def test_interactions(self):
from models import Protein, Site, Kinase, KinaseGroup
p1 = Protein(sites=[
Site(),
Site(kinases=[Kinase()], kinase_groups=[KinaseGroup()])
])
db.session.add(p1)
p2 = Protein(sites=[Site(kinases=[Kinase()])])
db.session.add(p2)
u_all_interactions = 0
u_kinases_covered = set()
u_kinase_groups_covered = set()
u_proteins_covered = set()
for protein in models.Protein.query.all():
for site in protein.sites:
kinases = site.kinases
kinase_groups = site.kinase_groups
u_all_interactions += len(kinases) + len(kinase_groups)
u_kinases_covered.update(kinases)
u_kinase_groups_covered.update(kinase_groups)
if kinases or kinase_groups:
u_proteins_covered.add(protein)
from stats import Statistics
statistics = Statistics()
all_interactions = statistics.interactions()
kinases_covered = statistics.kinases_covered()
kinase_groups_covered = statistics.kinase_groups_covered()
proteins_covered = statistics.proteins_covered()
assert all_interactions == u_all_interactions
assert kinases_covered == len(u_kinases_covered)
assert kinase_groups_covered == len(u_kinase_groups_covered)
assert proteins_covered == len(u_proteins_covered)
