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_session_url(self):
url = 'root'
session = molgenis.Session(url)
assert session._root_url == 'root/'
assert session._api_url == 'root/api/'
def __init__(self, molgenis_server, admin_password):
api_url = molgenis_server + '/api/'
# Create molgenis session with specified server
self.molgenis_client = molgenis.Session(api_url)
# Login as admin to server
self.molgenis_client.login('admin', admin_password)
def test_no_login_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
try:
s.get(self.user_entity)
except Exception as e:
message = e.args[0]
self.assertEqual(self.no_readmeta_permission_user_msg, message)
def test_no_login_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
try:
s._get_batch(self.user_entity)
except Exception as e:
response = e.args[1]
response.connection.close()
assert response.status_code == 401
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_no_login_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
try:
s._get_batch(self.user_entity)
except Exception as e:
message = e.args[0]
response = e.args[1]
response.connection.close()
self.assertEqual(self.no_readmeta_permission_user_msg, message)
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_login_logout_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
s.login('admin', self.password)
s.get(self.user_entity)
s.logout()
try:
s.get(self.user_entity)
except Exception as e:
message = e.args[0]
self.assertEqual(self.no_readmeta_permission_user_msg, message)
def test_login_logout_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
s.login('admin', self.password)
s.get(self.user_entity)
s.logout()
try:
s._get_batch(self.user_entity)
except Exception as e:
response = e.args[1]
response.connection.close()
assert response.status_code == 401
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 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.get_by_id(self.ref_entity, "ref55", ["label"])
self.assertEqual("updated-label55", item55["label"])
s.delete(self.ref_entity, 'ref55')
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_add_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_token_session_and_get_MolgenisUser(self):
token = 'token_session_test'
admin = self.session.get('sys_sec_User',
q='username==admin',
attributes='id')
self.session.add('sys_sec_Token',
data={
'User': admin[0]['id'],
'token': token,
'creationDate': '2000-01-01T01:01:01'
})
token_session = molgenis.Session(self.api_url, token=token)
token_session.get(self.user_entity)
token_session.logout()
try:
token_session._get_batch(self.user_entity)
except Exception as e:
response = e.args[1]
response.connection.close()
assert response.status_code == 401
from datetime import date, datetime
import molgenis.client as molgenis
# Define molgenis.session
gen_session = molgenis.Session('https://geneticlines.molgeniscloud.org/api/',
token='${molgenisToken}')
# Get a list with all adalasportaldata
adlasportal = gen_session.get('adlasportal_patients',
batch_size=1000,
sort_column='UMCGNR')
# Get a list with all IDs
keylist = gen_session.get('keylist_ids',
batch_size=1000,
sort_column='umcg_numr')
#add GEN_nr to adalasportaldata based on keylist
for x in adlasportal:
for y in keylist:
if x['UMCGNR'] == y['umcg_numr']:
x['GEN_numr'] = y['GEN_numr']
#make new headers for update
for d in adlasportal:
d['clinical_identifier'] = d['GEN_numr'] + '_' + d['ADVIESVRAAGNUMMER']
d['genetic_testcode'] = d.pop('TESTCODE')
d['lab_result_date'] = (d['LABUITSLAG_DATUM']).replace(" 00:00", "")
#'lab_results_id': #based on gene or CNV'samengestelde naam(clinical_id, testresult)
for d in adlasportal:
}[record['biobank']['ressource_types']['id']],
'homepage': None,
'publisher': record['biobank']['id'],
'diseases': [d['id'] for d in record['diagnosis_available']],
'country': record['country']['id']
}
def sync_entities(session, source_entity, dest_entity, transformer, **kwargs):
records_to_add = _get_records_to_add(session, source_entity, dest_entity,
**kwargs)
transformed_records = [transformer(r) for r in records_to_add]
_add_new_records(session, dest_entity, transformed_records)
s = client.Session('http://localhost:8080/api', token='${molgenisToken}')
sync_entities(s, BBMRI_COUNTRIES_ENTITY, EJPRD_LOCATIONS,
_locations_transformer)
sync_entities(s, BBMRI_DISEASE_ENTITY, EJPRD_DISEASES, _diseases_transformer)
sync_entities(s,
BBMRI_BIOBANKS_ENTITY,
EJPRD_PUBLISHERS,
_publishers_transformer,
attributes=BIOBANKS_ATTRIBUTES,
expand=BIOBANKS_EXPAND_ATTRIBUTES)
sync_entities(s,
BBMRI_COLLECTIONS_ENTITY,
EJPRD_RESOURCES,
_resources_transformer,
attributes=COLLECTIONS_ATTRIBUTES,
import matplotlib.pyplot as plt
import molgenis.client as molgenis
session = molgenis.Session("https://molgenis56.gcc.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))
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")
"sort1": "submitDate",
"sort2": "submitDate",
"token": '${molgenisToken}'
}
f1_list = []
#RUN test server
# #testserver session
# session = molgenis.Session(arguments["urlTest"])
#
# # testserver Login
# session.login(arguments["username"], arguments["password"])
# print("\nYou are logged in as: {}".format(arguments["username"]))
#RUN with scripts on MOLGENIS
# server session
session = molgenis.Session(arguments["url"], arguments["token"])
#threeyears ago
three_yrs_time = datetime.now() - relativedelta(years=3)
three_yrs_ago = three_yrs_time.strftime("%Y-%m-%d")
print(three_yrs_ago)
# Get all questionnaire info c6
questionnaires = session.get(arguments["entityType1"],
batch_size=1000,
sort_column=arguments["sort1"])
print("\nEntityType: {}".format(arguments["entityType1"]))
#Get all questionnaire info follow-up1
followUp1 = session.get(arguments["entityType2"],
batch_size=1000,
sort_column=arguments["sort2"])
"type": "unicorn"
}],
"updateAttr":
"year",
"updateVal":
"2000"
}
print(
"Running demonstration of MOLGENIS python API with following arguments: ")
for arg in arguments:
print('{}:{}'.format(arg, arguments[arg]))
# To run this script you should have molgenis running locally, otherwise replace the url below with the url of your
# server
session = molgenis.Session(arguments["url"])
# Login
session.login(arguments["username"], arguments["password"])
print("\nYou are logged in as: {}".format(arguments["username"]))
# Upload zip
response = session.upload_zip("resources/{}.zip".format(
arguments["filename"])).split("/")
# An upload is asynchronous, so you should check when it is done if you want to work with the data further on.
# The response of this query is the location of the row in the importRun entity via the REST api
runEntityType = response[-2]
runId = response[-1]
statusInfo = session.get_by_id(runEntityType, runId)
count = 1
print("\r{} uploading{}".format(arguments["entityType"], count * "."), end='')
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 connect_to_server(server_url, pw, username="******"):
session = molgenis.Session(server_url + "api/")
session.login(username, pw)
return session
import molgenis.client as molgenis
from datetime import datetime
import pprint
# Save variables used through the entire script (not all are here,needs cleaning):
arguments = {
"entityType1": "adlasportal_adlasData",
"entityType2": "epicportal_patients",
"entityType3": 'epicportal_consent',
"entityType4": "geneticlines_individualconsent",
"url": "http://localhost:8080/api/",
"sort1": "UMCGNR",
"sort2": "MRN"
}
# server session
session = molgenis.Session(arguments["url"], token="${molgenisToken}")
# Get a list with all adalasportaldata en tests
adlas = session.get(arguments["entityType1"],
batch_size=1000,
sort_column=arguments["sort1"])
print("\nEntityType: {}".format(arguments["entityType1"]))
epic = session.get(arguments["entityType2"],
batch_size=1000,
sort_column=arguments["sort2"])
print("\nEntityType: {}".format(arguments["entityType2"]))
storage = session.get(arguments["entityType3"], batch_size=1000)
print("\nEntityType: {}".format(arguments["entityType3"]))
#get unique entries per gen_numr
personal = list({v['GEN_numr']: v for v in adlas}.values())
class TestStringMethods(unittest.TestCase):
"""
Tests the client against a running MOLGENIS.
"""
host = os.getenv('CI_HOST', 'http://localhost:8080')
password = os.getenv('CI_PASSWORD', 'admin')
api_url = host + "/api/"
no_readmeta_permission_user_msg = "401 Client Error: for url: {}v2/sys_sec_User: No 'Read metadata' " \
"permission on entity type 'User' with id 'sys_sec_User'.".format(api_url)
user_entity = 'sys_sec_User'
ref_entity = 'org_molgenis_test_python_TypeTestRef'
expected_ref_data = [
{
'_href': '/api/v2/org_molgenis_test_python_TypeTestRef/ref1',
'value': 'ref1',
'label': 'label1'
},
{
'_href': '/api/v2/org_molgenis_test_python_TypeTestRef/ref2',
'value': 'ref2',
'label': 'label2'
},
{
'_href': '/api/v2/org_molgenis_test_python_TypeTestRef/ref3',
'value': 'ref3',
'label': 'label3'
},
{
'_href': '/api/v2/org_molgenis_test_python_TypeTestRef/ref4',
'value': 'ref4',
'label': 'label4'
},
{
'_href': '/api/v2/org_molgenis_test_python_TypeTestRef/ref5',
'value': 'ref5',
'label': 'label5'
},
]
session = molgenis.Session(api_url)
session.login('admin', password)
def _try_delete(self, entity_type, entity_ids):
# Try to remove because if a previous test failed, possibly the refs you're about to add are not removed yet
try:
self.session.delete_list(entity_type, entity_ids)
except Exception as e:
print(e)
def _try_add(self, entity_type, entities):
# Try to add because if a previous test failed, possibly the refs you're about to reove are not added yet
try:
self.session.add_all(entity_type, entities)
except Exception as e:
print(e)
@classmethod
def setUpClass(cls):
cwd = os.getcwd()
if cwd.endswith('tests'):
os.chdir('..')
response = cls.session.upload_zip(
'./tests/resources/all_datatypes.zip').split('/')
run_entity_type = response[-2]
run_id = response[-1]
status_info = cls.session.get_by_id(run_entity_type, run_id)
while status_info['status'] == 'RUNNING':
status_info = cls.session.get_by_id(run_entity_type, run_id)
@classmethod
def tearDownClass(cls):
cls.session.delete('sys_md_Package', 'org')
cls.session.logout()
def test_login_logout_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
s.login('admin', self.password)
s.get(self.user_entity)
s.logout()
try:
s._get_batch(self.user_entity)
except Exception as e:
message = e.args[0]
response = e.args[1]
response.connection.close()
self.assertEqual(self.no_readmeta_permission_user_msg, message)
def test_no_login_and_get_MolgenisUser(self):
s = molgenis.Session(self.api_url)
try:
s._get_batch(self.user_entity)
except Exception as e:
message = e.args[0]
response = e.args[1]
response.connection.close()
self.assertEqual(self.no_readmeta_permission_user_msg, message)
def test_upload_zip(self):
self._try_delete('sys_md_EntityType',
['org_molgenis_test_python_sightings'])
response = self.session.upload_zip(
'./tests/resources/sightings_test.zip').split('/')
run_entity_type = response[-2]
run_id = response[-1]
status_info = self.session.get_by_id(run_entity_type, run_id)
while status_info['status'] == 'RUNNING':
status_info = self.session.get_by_id(run_entity_type, run_id)
self.assertEqual('FINISHED', status_info['status'])
def test_delete_row(self):
self._try_add(self.ref_entity, [{
"value": "ref55",
"label": "label55"
}])
response = self.session.delete(self.ref_entity, 'ref55')
self.assertEqual(str(response), '<Response [204]>',
'Check status code')
items = self.session.get(self.ref_entity)
self.assertEqual(
len(items), 5,
'Check if items that were not deleted are still present')
no_items = self.session.get(self.ref_entity, q='value=in=(ref55)')
self.assertEqual(len(no_items), 0,
'Check if item that was deleted is really deleted')
def test_delete_data(self):
self._try_delete('sys_md_EntityType',
['org_molgenis_test_python_sightings'])
response = self.session.upload_zip(
'./tests/resources/sightings_test.zip').split('/')
run_entity_type = response[-2]
run_id = response[-1]
status_info = self.session.get_by_id(run_entity_type, run_id)
while status_info['status'] == 'RUNNING':
status_info = self.session.get_by_id(run_entity_type, run_id)
self.session.delete('org_molgenis_test_python_sightings')
number_of_rows = self.session.get('org_molgenis_test_python_sightings',
raw=True)['total']
self.assertEqual(0, number_of_rows)
def test_add_all(self):
self._try_delete(self.ref_entity, ['ref55', 'ref57'])
response = self.session.add_all(self.ref_entity, [{
"value": "ref55",
"label": "label55"
}, {
"value": "ref57",
"label": "label57"
}])
self.assertEqual(['ref55', 'ref57'], response)
item55 = self.session.get(self.ref_entity, q="value==ref55")[0]
self.assertEqual(
{
"value": "ref55",
"label": "label55",
"_href": "/api/v2/" + self.ref_entity + "/ref55"
}, item55)
self.session.delete(self.ref_entity, 'ref55')
self.session.delete(self.ref_entity, 'ref57')
def test_add_all_error(self):
try:
self.session.add_all(self.ref_entity, [{"value": "ref55"}])
except Exception as e:
message = e.args[0]
expected = "400 Client Error: for url: {}v2/org_molgenis_test_python_TypeTest" \
"Ref: The attribute 'label' of entity 'org_molgenis_test_python_TypeTestRef' can not be null.".format(
self.api_url)
self.assertEqual(expected, message)
def test_delete_list(self):
self._try_add(self.ref_entity, [{
"value": "ref55",
"label": "label55"
}, {
"value": "ref57",
"label": "label57"
}])
response = self.session.delete_list(self.ref_entity,
['ref55', 'ref57'])
self.assertEqual(str(response), '<Response [204]>',
'Check status code')
items = self.session.get(self.ref_entity)
self.assertEqual(
len(items), 5,
'Check if items that were not deleted are still present')
no_items = self.session.get(self.ref_entity,
q='value=in=(ref55,ref57)')
self.assertEqual(
len(no_items), 0,
'Check if items that were deleted are really deleted')
def test_add_dict(self):
self._try_delete(self.ref_entity, ['ref55'])
self.assertEqual(
'ref55',
self.session.add(self.ref_entity, {
"value": "ref55",
"label": "label55"
}))
self.session.delete(self.ref_entity, 'ref55')
def test_update_one(self):
self._try_delete(self.ref_entity, ['ref55'])
self.assertEqual(
'ref55',
self.session.add(self.ref_entity, {
"value": "ref55",
"label": "label55"
}))
try:
self.session.update_one(self.ref_entity, 'ref55', 'label',
'updated-label55')
except Exception as e:
raise Exception(e)
item55 = self.session.get_by_id(self.ref_entity, "ref55", ["label"])
self.assertEqual("updated-label55", item55["label"])
self.session.delete(self.ref_entity, 'ref55')
def test_update_one_error(self):
try:
self.session.update_one(self.ref_entity, 'ref555', 'label',
'updated-label555')
except Exception as e:
message = e.args[0]
expected = "404 Client Error: for url: {}v1/org_molgenis_test_python_TypeTestRef" \
"/ref555/label: Unknown entity with 'value' 'ref555' of type 'TypeTestRef'.".format(self.api_url)
self.assertEqual(expected, message)
def test_add_kwargs(self):
self._try_delete(self.ref_entity, ['ref55'])
self.assertEqual(
'ref55',
self.session.add(self.ref_entity, value="ref55", label="label55"))
item55 = self.session.get(self.ref_entity, q="value==ref55")[0]
self.assertEqual(
{
"value": "ref55",
"label": "label55",
"_href": "/api/v2/" + self.ref_entity + "/ref55"
}, item55)
self.session.delete(self.ref_entity, 'ref55')
def test_add_merge_dict_kwargs(self):
self._try_delete(self.ref_entity, ['ref55'])
self.assertEqual(
'ref55',
self.session.add(self.ref_entity, {"value": "ref55"},
label="label55"))
item55 = self.session.get(self.ref_entity, q="value==ref55")[0]
self.assertEqual(
{
"value": "ref55",
"label": "label55",
"_href": "/api/v2/" + self.ref_entity + "/ref55"
}, item55)
self.session.delete(self.ref_entity, 'ref55')
def test_get(self):
data = self.session.get(self.ref_entity)
self.assertEqual(self.expected_ref_data, data)
def test_get_raw(self):
data = self.session.get(self.ref_entity, raw=True)
self.assertTrue('meta' in data)
self.assertTrue('items' in data)
def test_get_query(self):
data = self.session.get(self.ref_entity, q='value==ref1')
expected = [{
'_href': '/api/v2/org_molgenis_test_python_TypeTestRef/ref1',
'value': 'ref1',
'label': 'label1'
}]
self.assertEqual(expected, data)
def test_get_num(self):
data = self.session.get(self.ref_entity, num=2)
self.assertEqual(2, len(data))
def test_get_batch(self):
data = self.session.get(self.ref_entity, batch_size=2)
self.assertEqual(self.expected_ref_data, data)
def test_get_expand(self):
data = self.session.get(self.ref_entity.replace('Ref', ''),
expand='xcomputedxref')
first_item = data[0]
expected = {
"_href": "/api/v2/org_molgenis_test_python_Location/5",
"Chromosome": "str1",
"Position": 5
}
self.assertEqual(47, len(first_item))
self.assertEqual(expected, first_item['xcomputedxref'])
def test_get_expand_attrs(self):
data = self.session.get(self.ref_entity.replace('Ref', ''),
expand='xcomputedxref',
attributes='id,xcomputedxref')
first_item = data[0]
expected = {
"_href": "/api/v2/org_molgenis_test_python_Location/5",
"Chromosome": "str1",
"Position": 5
}
self.assertEqual(len(first_item), 3)
self.assertEqual(expected, first_item['xcomputedxref'])
def test_get_meta(self):
meta = self.session.get_entity_meta_data(self.user_entity)
self.assertEqual('username', meta['labelAttribute'])
def test_get_attribute_meta(self):
meta = self.session.get_attribute_meta_data(self.user_entity,
'username')
self.assertEqual(
{
'href':
'/api/v1/sys_sec_User/meta/username',
'fieldType':
'STRING',
'name':
'username',
'label':
'Username',
'attributes': [],
'enumOptions': [],
'maxLength':
255,
'auto':
False,
'nillable':
False,
'readOnly':
True,
'labelAttribute':
True,
'unique':
True,
'visible':
True,
'lookupAttribute':
True,
'isAggregatable':
False,
'validationExpression':
"$('username').matches(/^[\\S].+[\\S]$/).value()"
}, meta)
def test_build_api_url_complex(self):
base_url = 'https://test.frl/api/test'
possible_options = {
'q': 'x==1',
'attrs': ['x,y', 'y'],
'num': 1000,
'start': 1000,
'sort': ['x', 'desc']
}
generated_url = self.session._build_api_url(base_url, possible_options)
# Only check the contents of the operators because their order is random
expected_sort = 'x:desc'
expected_attrs = ['x', 'y(*)']
expected_num = '1000'
expected_start = '1000'
expected_q = 'q=x==1'
operators = generated_url.split('?')[1].split('&')
observed_q = operators[0]
observed_attrs = operators[1].replace('attrs=', '').split(',')
observed_num = operators[2].replace('num=', '')
observed_start = operators[3].replace('start=', '')
observed_sort = operators[4].replace('sort=', '')
self.assertEqual(expected_q, observed_q)
self.assertEqual(expected_num, observed_num)
self.assertEqual(expected_start, observed_start)
self.assertEqual(expected_sort, observed_sort)
self.assertEqual(sorted(expected_attrs), sorted(observed_attrs))
def test_build_api_url_simple(self):
base_url = 'https://test.frl/api/test'
possible_options = {
'q': None,
'attrs': [None, None],
'num': 100,
'start': 0,
'sort': [None, None]
}
generated_url = self.session._build_api_url(base_url, possible_options)
expected = 'https://test.frl/api/test'
self.assertEqual(expected, generated_url)
def test_build_api_url_less_complex(self):
base_url = 'https://test.frl/api/test'
possible_options = {
'q': None,
'attrs': [None, 'y'],
'num': 100,
'start ': 0,
'sort': ['x', None]
}
generated_url = self.session._build_api_url(base_url, possible_options)
# Only check the contents of the operators because their order is random
expected_sort = 'x'
expected_attrs = ['*', 'y(*)']
operators = generated_url.split('?')[1].split('&')
observed_attrs = operators[0].replace('attrs=', '').split(',')
observed_sort = operators[1].replace('sort=', '')
self.assertEqual(expected_sort, observed_sort)
self.assertEqual(sorted(expected_attrs), sorted(observed_attrs))
def test_build_api_url_error(self):
base_url = 'https://test.frl/api/test'
possible_options = {
'q': [{
"field": "x",
"operator": "EQUALS",
"value": "1"
}],
'attrs': [None, 'y'],
'num': 100,
'start': 0,
'sort': ['x', None]
}
with self.assertRaises(TypeError):
self.session._build_api_url(base_url, possible_options)
def test_raise_exception_with_missing_content(self):
msg = 'message'
ex = ExceptionMock(msg, None)
try:
self.session._raise_exception(ex)
except Exception as e:
message = e.args[0]
expected = msg
self.assertEqual(expected, message)
# the job locally, you can either copy your username and password in the
# script or in an `.env` file. If you are using a .env file, create two
# entries ('MOLGENIS_USERNAME' and 'MOLGENIS_PASSWORD') and run the script.
#////////////////////////////////////////////////////////////////////////////
import molgenis.client as molgenis
from datetime import datetime
import pytz
# ~ Local Dev ~
from dotenv import load_dotenv
from os import environ
load_dotenv()
host = environ['MOLGENIS_HOST_PROD']
db = molgenis.Session(url=host)
db.login(username=environ['MOLGENIS_USERNAME'],
password=environ['MOLGENIS_PASSWORD'])
# ~ Deployed ~
# when deployed
# host='http://localhost/api'
# token='${molgenisToken}'
# db = molgenis.Session(url=host, token=token)
def molgenisApiTimestamp(tz='Europe/Amsterdam'):
"""Molgenis API Timestamp
Create ISO 8601 timestamp minus UTC offset for use in API requests
@param tz an IANA time zone
import molgenis.client as molgenis
session = molgenis.Session("http://localhost:8080/api/")
session.login('admin', 'admin')
response = session.upload_zip("resources/upload.zip").split('/')
runEntityType = response[-2]
runId = response[-1]
statusInfo = session.get_by_id(runEntityType, runId)
count = 1
print("Uploading org_molgenis_test_python_TypeTest")
while statusInfo['status'] == 'RUNNING':
count += 1
print('.')
statusInfo = session.get_by_id(runEntityType, runId)
if statusInfo["status"] == "FINISHED":
print("org_molgenis_test_python_TypeTest uploaded")
if statusInfo["status"] == "FAILED":
print("Failed: ", statusInfo['message'])
session.delete_list("org_molgenis_test_python_TypeTest", ["1", "2", "3"])
print("deleted first three rows")
202010 Dieuwke Roelofs-Prins
With this script:
- Entries which are in BBMRI ERIC persons, networks, biobanks and
collections which do not exist in het National Node data will be
deleted.
"""
# Import module(s)
import molgenis.client as molgenis
# Define variable(s)
bb_qualities={}
check_list=['collections', 'biobanks', 'networks', 'persons']
debug=False
col_qualities={}
eric_session = molgenis.Session('https://molgenis104.gcc.rug.nl/api/', token='${molgenisToken}')
nn_ids=[]
nn_packages=[]
### Get a list with all eu_bbmri_eric packages
eric_packages=eric_session.get('sys_md_Package', attributes='id', batch_size=1000, sort_column='id', q='id=like="eu_bbmri_eric"')
if len(eric_packages) == 0:
raise SystemExit('No ERIC packages found?!?')
else: print('Number ERIC packages is', len(eric_packages))
# Store the packages in a list
for package in eric_packages:
if package['id'] != 'eu_bbmri_eric':
nn_packages.append(package['id'])
print('Number of National Node packages is', len(nn_packages))
