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))