def __init__(self):
self.config = MolgenisConfigParser('config.txt').config
self.session = molgenis.Session(self.config['url'])
self.session.login(self.config['account'], self.config['password'])
labs = self.config['labs'].split(',')
self.labClassifications = dict.fromkeys(labs, [])
self.get_paginated_table_content()
def test_no_login_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
try:
s.get(self.user_entity)
except requests.exceptions.HTTPError as e:
self.assertEqual(e.response.status_code, 401)
self.assertEqual(e.response.json()['errors'][0]['message'], self.no_readmeta_permission_user_msg)
def test_add_all(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
try:
s.delete(self.ref_entity, 'ref55')
s.delete(self.ref_entity, 'ref57')
except Exception as e:
print(str(e))
response = s.add_all(self.ref_entity, [{
"value": "ref55",
"label": "label55"
}, {
"value": "ref57",
"label": "label57"
}])
self.assertEqual(['ref55', 'ref57'], response)
item55 = s.get(self.ref_entity,
q=[{
"field": "value",
"operator": "EQUALS",
"value": "ref55"
}])[0]
self.assertEqual(
{
"value": "ref55",
"label": "label55",
"href": "/api/v1/" + self.ref_entity + "/ref55"
}, item55)
s.delete(self.ref_entity, 'ref55')
s.delete(self.ref_entity, 'ref57')
def test_no_login_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
try:
s.get('MolgenisUser')
except requests.exceptions.HTTPError as e:
self.assertEqual(e.response.status_code, 401)
self.assertEqual(e.response.json()['errors'][0]['message'],
'No READ permission on entity MolgenisUser')
def test_add_dict(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
try:
s.delete(self.ref_entity, 'ref55')
except Exception as e:
print(str(e))
self.assertEqual('ref55', s.add(self.ref_entity, {"value": "ref55", "label": "label55"}))
s.delete(self.ref_entity, 'ref55')
def main():
config = MolgenisConfigParser('config.txt').config
labs = config['labs'].split(',')
url = config['url']
account = config['account']
pwd = config['password']
session = molgenis.Session(url)
session.login(account, pwd)
consensus = ConsensusTableGenerator(labs, session, 'omim.txt')
def test_get_attribute_meta(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
meta = s.get_attribute_meta_data(self.user_entity, 'username')
self.assertEqual({'labelAttribute': True, 'isAggregatable': False, 'name': 'username',
'auto': False, 'nillable': False, 'label': 'Username', 'lookupAttribute': True,
'visible': True, 'readOnly': True, 'href': '/api/v1/sys_sec_User/meta/username',
'enumOptions': [], 'fieldType': 'STRING', 'maxLength': 255, 'attributes': [],
'unique': True},
meta)
def test_login_logout_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
response = s.get(self.user_entity)
s.logout()
try:
response = s.get(self.user_entity)
except requests.exceptions.HTTPError as e:
self.assertEqual(e.response.status_code, 401)
self.assertEqual(e.response.json()['errors'][0]['message'], self.no_count_permission_user_msg)
def main():
config = MolgenisConfigParser('config.txt').config
server = config['url']
account = config['account']
consensus_table = config['consensus_table']
pwd = config['password']
session = molgenis.Session(server)
session.login(account, pwd)
cc = ConsensusCounter(consensus_table, session)
session.logout()
def test_login_and_get_superuser_username(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
response = s.get(self.user_entity,
q=[{
"field": "superuser",
"operator": "EQUALS",
"value": "true"
}])
self.assertEqual('admin', response[0]['username'])
def test_add_merge_dict_kwargs(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
try:
s.delete(self.ref_entity, 'ref55')
except Exception as e:
print(str(e))
self.assertEqual('ref55', s.add(self.ref_entity, {"value": "ref55"}, label="label55"))
item55 = s.get(self.ref_entity, q=[{"field": "value", "operator": "EQUALS", "value": "ref55"}])[0]
self.assertEqual({"value": "ref55", "label": "label55", "href": "/api/v1/" + self.ref_entity + "/ref55"},
item55)
s.delete(self.ref_entity, 'ref55')
def test_update_one(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
try:
s.delete(self.ref_entity, 'ref55')
except Exception as e:
print(str(e))
self.assertEqual('ref55', s.add(self.ref_entity, {"value": "ref55", "label": "label55"}))
try:
s.update_one(self.ref_entity, 'ref55', 'label', 'updated-label55');
except Exception as e:
print(str(e))
item55 = s.getById(self.ref_entity, "ref55", ["label"])
self.assertEqual("updated-label55", item55["label"])
s.delete(self.ref_entity, 'ref55')
def __init__(self, raw_file, use_raw=False, export=True):
self.config = MolgenisConfigParser("config.txt").config
labs = self.config['labs'].split(',')
self.labClassifications = dict((lab, []) for lab in labs)
if use_raw:
self.raw_file = open(raw_file)
print(
"Reading from server skipped, reading from previously generated {}"
.format(raw_file))
self.parse_raw()
else:
self.raw_file = open(raw_file, "w")
self.session = molgenis.Session(self.config['url'])
self.session.login(self.config['account'], self.config['password'])
self.get_paginated_table_content()
self.session.logout()
self.save_raw_output()
if export:
self.write_output()
def test_get_attribute_meta(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
meta = s.get_attribute_meta_data('MolgenisUser', 'username')
self.assertEqual(
{
'aggregateable': False,
'attributes': [],
'auto': False,
'description': '',
'fieldType': 'STRING',
'href': '/api/v1/MolgenisUser/meta/username',
'label': 'Username',
'labelAttribute': True,
'lookupAttribute': True,
'maxLength': 255,
'nillable': False,
'readOnly': False,
'unique': True,
'visible': True,
'name': 'username'
}, meta)
def test_add_kwargs(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
try:
s.delete('TypeTestRef', 'ref55')
except Exception as e:
print(str(e))
self.assertEqual('ref55',
s.add('TypeTestRef', value="ref55", label="label55"))
item55 = s.get('TypeTestRef',
q=[{
"field": "value",
"operator": "EQUALS",
"value": "ref55"
}])[0]
self.assertEqual(
{
"value": "ref55",
"label": "label55",
"href": "/api/v1/TypeTestRef/ref55"
}, item55)
s.delete('TypeTestRef', 'ref55')
def test_get_meta(self):
s = molgenis.Session(self.api_url)
s.login('admin', 'admin')
meta = s.get_entity_meta_data(self.user_entity)
self.assertEqual('username', meta['labelAttribute'])
def __init__(self, url, username, password):
self.session = molgenis.Session(url)
self.session.login(username, password)
import molgenis
session = molgenis.Session("https://molgenis56.target.rug.nl/api/")
dir(session)
session.get("ASE")
print(
session.get("ASE",
q=[{
"field": "SNP_ID",
"operator": "EQUALS",
"value": "rs12460890"
}]))
samples = session.get("SampleAse",
q=[{
"field": "SNP_ID",
"operator": "EQUALS",
"value": "rs12460890"
}])
print(samples)
for sample in samples:
print("{Ref_Counts:5} {Alt_Counts:5}".format(**sample))
import matplotlib.pyplot as plt
plt.scatter([sample["Ref_Counts"] for sample in samples],
[sample["Alt_Counts"] for sample in samples])
plt.xlim([0, 5000])
plt.ylim([0, 5000])
plt.xlabel("Reference Allele")
plt.ylabel("Alternative Allele")
plt.title("Allele-Specific Expression for rs12460890")
plt.plot([0, 5000], [0, 5000])
plt.show()
def __init__(self, url):
self.url = url
session = molgenis.Session(url)
session.login("admin", "admin")
'''
Genomic location annotator.
Annotates the #CHROM/POS location of each variant with the name of the chromosomal band and optionally the id of an exon
it is located in.
This script expects three entities to be present:
gf_gh_Variant, gf_gh_Band and gf_gh_Exon
It downloads the variants, and for each row looks up the band and exon.
It updates the variants with this information.
Tested with python 3.
N.B. Make sure to actually read the script and update the string values (e.g. port number!) to match your situation
'''
session = molgenis.Session('http://localhost:8081/api/')
session.login('admin', 'admin')
pagesize = 1000
for page in range(0, 1):
variants = session.get('gf_gh_Variant',
num=pagesize,
start=page * pagesize)
for variant in variants:
query = '#CHROM=q={chrom};END=gt={pos};START=le={pos}'.format(
chrom=variant['#CHROM'], pos=variant['POS'])
band = session.getv2('gf_gh_Band', query)
variant['BAND'] = band[0]['NAME']
exon = session.getv2('gf_gh_Exon', query)
if exon:
variant['EXON'] = exon[0]['ID']
session.update_all('gf_gh_Variant', variants)
