def test_empty_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
(s, rs) = epidb.info("", self.admin_key)
self.assertEquals(rs, [])
(s, rs) = epidb.info([], self.admin_key)
self.assertEquals(rs, [])
def test_info_on_user_queries(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
res, user_one = epidb.add_user("user1", "*****@*****.**", "test",
self.admin_key)
self.assertSuccess(res, user_one)
s, tmp_user = epidb.modify_user_admin(user_one[0], "permission_level",
"GET_DATA", self.admin_key)
self.assertSuccess(s)
res, user_two = epidb.add_user("user2", "*****@*****.**", "test",
self.admin_key)
self.assertSuccess(res, user_two)
s, tmp_user = epidb.modify_user_admin(user_two[0], "permission_level",
"GET_DATA", self.admin_key)
self.assertSuccess(s)
(s, t1) = epidb.tiling_regions(100, "hg19", "chr1", user_one[1])
s = epidb.info(t1, user_one[1])
self.assertEquals(s, [
'okay',
[{
'_id': 'q1',
'type': 'tiling',
'user': '******',
'args': {
"genome": "hg19",
"size": 100,
"chromosomes": ["chr1"]
}
}]
])
s = epidb.info(t1, user_two[1])
self.assertEquals(s, [
'error',
"111003:You are not the query ID 'q1' owner and neither an administrator."
])
s = epidb.info(t1, self.admin_key)
self.assertEquals(s, [
'okay',
[{
'_id': 'q1',
'type': 'tiling',
'user': '******',
'args': {
"genome": "hg19",
"size": 100,
"chromosomes": ["chr1"]
}
}]
])
def test_set_project_public(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
s, user = epidb.add_user("user", "email", "institution",
self.admin_key)
(user_id, user_key) = user
self.assertSuccess(s)
s, info = epidb.info("me", user_key)
self.assertSuccess(s, info)
(s, uid) = epidb.modify_user_admin(user_id, "permission_level",
"INCLUDE_EXPERIMENTS",
self.admin_key)
res = epidb.add_project("Other", "Some other project", user_key)
self.assertSuccess(res)
res = epidb.set_project_public("Other", True, user_key)
self.assertSuccess(res)
res = epidb.add_project("Other2", "Some other project2", user_key)
self.assertSuccess(res)
res = epidb.set_project_public("Other2", True, self.admin_key)
self.assertSuccess(res)
def test_search_synonyms(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
res, bsid1 = epidb.add_biosource("Bio Source A", "bio source A", {}, self.admin_key)
self.assertSuccess(res, bsid1)
res = epidb.set_biosource_synonym("bio source a", "synonym name for bio source a", self.admin_key)
self.assertSuccess(res)
res = epidb.set_biosource_synonym("bio source a", "bla bla blu blu", self.admin_key)
self.assertSuccess(res)
res = epidb.set_biosource_synonym("synonym name for bio source a", "another synonym", self.admin_key)
self.assertSuccess(res)
(res, found) = epidb.search("another synonym", None, self.admin_key)
self.assertEquals(found, [['bs3', 'Bio Source A', 'biosources'], ['t2', 'tech2', 'techniques']])
(res, found) = epidb.search("bla bla blu blu", None, self.admin_key)
self.assertEquals(found, [['bs3', 'Bio Source A', 'biosources']])
(res, info) = epidb.info(bsid1, self.admin_key)
self.assertSuccess(res, info)
self.assertEquals(info[0], {'description': 'bio source A', 'user': '******', '_id': 'bs3', 'type': 'biosource', 'name': 'Bio Source A'})
def test_query_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
sample_id = self.sample_ids[0]
self.insert_experiment(epidb, "hg19_chr1_1", sample_id)
res, qid = epidb.select_regions("hg19_chr1_1", "hg19", "Methylation", sample_id, "tech1",
"ENCODE", "chr1", 713500, 850000, self.admin_key)
self.assertSuccess(res, qid)
res, data = epidb.info(qid, self.admin_key)
self.assertSuccess(res, data)
self.assertEqual(data[0]['_id'], qid)
self.assertEqual(data[0]['type'], 'experiment_select')
self.assertEqual(data[0]['args'], { "experiment_name" : [ "hg19_chr1_1" ], "genomes": ["hg19"], "epigenetic_mark" : [ "Methylation" ], "sample_id" : [ "s1" ], "project" : [ "ENCODE" ], "technique" : [ "tech1" ], "start" : 713500, "end" : 850000, "chromosomes" : [ "chr1" ]})
self.assertEqual(data[0]['user'], 'test_admin')
res, qid = epidb.select_experiments("hg19_chr1_1", ["chr1", "chr2"], 1713500, 1850000, self.admin_key)
self.assertSuccess(res, qid)
res, data = epidb.info(qid, self.admin_key)
self.assertSuccess(res, data)
self.assertEqual(data[0]['_id'], qid)
self.assertEqual(data[0]['type'], 'experiment_select')
self.assertEqual(data[0]['args'], { "experiment_name" : [ "hg19_chr1_1" ], "start" : 1713500, "end" : 1850000, "chromosomes" : [ "chr1", "chr2" ]})
self.assertEqual(data[0]['user'], 'test_admin')
res, qid = epidb.select_experiments("hg19_chr1_1", ["chr1", "chr2"], None, 1850000, self.admin_key)
self.assertSuccess(res, qid)
res, data = epidb.info(qid, self.admin_key)
self.assertSuccess(res, data)
self.assertEqual(data[0]['_id'], qid)
self.assertEqual(data[0]['type'], 'experiment_select')
self.assertEqual(data[0]['args'], { "experiment_name" : [ "hg19_chr1_1" ], "end" : 1850000, "chromosomes" : [ "chr1", "chr2" ]})
self.assertEqual(data[0]['user'], 'test_admin')
res, qid = epidb.select_experiments("hg19_chr1_1", "chr1", 10000, None, self.admin_key)
self.assertSuccess(res, qid)
res, data = epidb.info(qid, self.admin_key)
self.assertSuccess(res, data)
self.assertEqual(data[0]['_id'], qid)
self.assertEqual(data[0]['type'], 'experiment_select')
self.assertEqual(data[0]['args'], { "experiment_name" : [ "hg19_chr1_1" ], "start" : 10000, "chromosomes" : ["chr1"]})
self.assertEqual(data[0]['user'], 'test_admin')
def count_request(self, req):
if req[0] is not 'r':
print "Invalid request " + req
return
epidb = DeepBlueClient(address="localhost", port=31415)
sleep = 0.1
(s, ss) = epidb.info(req, self.admin_key)
while ss[0]["state"] != "done":
time.sleep(sleep)
(s, ss) = epidb.info(req, self.admin_key)
sleep += sleep
(s, data) = epidb.get_request_data(req, self.admin_key)
self.assertSuccess(s, data)
return data["count"]
def __get_regions_request(self, req, status=["done"]):
if req[0] is not 'r':
print "Invalid request " + req
return
epidb = DeepBlueClient(address="localhost", port=31415)
sleep = 0.1
count = 0
(s, ss) = epidb.info(req, self.admin_key)
while ss[0]["state"] not in status:
time.sleep(sleep)
(s, ss) = epidb.info(req, self.admin_key)
sleep += 0.5
count += 1
if count > 5:
print ss
(s, data) = epidb.get_request_data(req, self.admin_key)
return (s, data)
def test_change_extra_metadata(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
sample_id = self.sample_ids[0]
regions_data = "chr1\t1\t100"
format = ""
# adding two experiments with the same data should work
res = epidb.add_experiment("test_exp1", "hg19", "Methylation",
sample_id, "tech1", "ENCODE", "desc1",
regions_data, format, {
"NAME": "FELIPE",
"LAST_NAME": "ALBRECHT"
}, self.admin_key)
self.assertSuccess(res)
_id = res[1]
res = epidb.change_extra_metadata(_id, "NAME", "JOSE", self.admin_key)
self.assertSuccess(res)
res = epidb.change_extra_metadata(_id, "LAST_NAME", "FERNANDES",
self.admin_key)
self.assertSuccess(res)
status, info = epidb.info(_id, self.admin_key)
self.assertSuccess(status, info)
self.assertEqual({
"NAME": "JOSE",
"LAST_NAME": "FERNANDES"
}, info[0]["extra_metadata"])
(status, ss) = epidb.search("JOSE", "", self.admin_key)
self.assertEqual(1, len(ss))
(status, ss) = epidb.search("FELIPE", "", self.admin_key)
self.assertEqual(0, len(ss))
res = epidb.change_extra_metadata(sample_id, "source", "ENCODE",
self.admin_key)
self.assertSuccess(res)
s, info = epidb.info(sample_id, self.admin_key)
self.assertEqual(info[0]["source"], "ENCODE")
def test_request_info_permission(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_full(epidb)
s, user = epidb.add_user("user1", "*****@*****.**", "test", self.admin_key)
id, user_key = user
s, _id = epidb.modify_user_admin(id, "permission_level", "INCLUDE_COLLECTION_TERMS", self.admin_key)
self.assertSuccess(s, _id)
s, id = epidb.add_epigenetic_mark("DNA Methylation", "", {}, user_key)
self.assertSuccess(s, id)
s, query_id = epidb.select_regions(None, "hg19", "DNA Methylation", None, None, None, "chr1", None, None, user_key)
self.assertSuccess(s, query_id)
s, request_id = epidb.get_regions(query_id, "CHROMOSOME,START,END", user_key)
s, info = epidb.info(request_id, user_key)
self.assertSuccess(s, info)
s, info = epidb.info(request_id, self.admin_key)
self.assertSuccess(s, info)
def test_me_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
s, info = epidb.info("me", self.admin_key)
self.assertSuccess(s)
info = info[0]
self.assertTrue("name" in info and info["name"] == settings.EPIDB_TEST_ADMIN[0])
self.assertTrue("email" in info and info["email"] == settings.EPIDB_TEST_ADMIN[1])
self.assertTrue("institution" in info and info["institution"] == settings.EPIDB_TEST_ADMIN[2])
self.assertTrue("permission_level" in info and info["permission_level"] == "ADMIN")
def test_add_techniques(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
res = epidb.add_technique("ChIP-seq", "ChIP-sequencing", {},
self.admin_key)
self.assertSuccess(res)
res, info = epidb.info(res[1], self.admin_key)
self.assertSuccess(res, info)
self.assertEquals(info[0]["name"], 'ChIP-seq')
self.assertEquals(info[0]["description"], "ChIP-sequencing")
def test_clone_annotatation(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
aid1 = self.insert_annotation(epidb, "Cpg Islands")
(s, id_clone_no_columns) = epidb.clone_dataset(aid1, "New CpG Islands",
"", "", "", "", "", "",
{"new": "true"},
self.admin_key)
self.assertSuccess(s, id_clone_no_columns)
(s, info) = epidb.info(id_clone_no_columns, self.admin_key)
info[0]['upload_info']['upload_end'] = '0'
info[0]['upload_info']['upload_start'] = '0'
info[0]['upload_info']['total_size'] = '0'
info[0]['upload_info']['client_address'] = '0'
self.assertEqual(
info[0], {
'format':
'CHROMOSOME,START,END',
'extra_metadata': {
'new': 'true'
},
'upload_info': {
'client_address': '0',
'total_size': '0',
'content_format': 'peaks',
'upload_start': '0',
'upload_end': '0',
'done': 'true',
'user': '******'
},
'name':
'New CpG Islands',
'genome':
'hg19',
'_id':
'a4',
'type':
'annotation',
'columns': [{
'name': 'CHROMOSOME',
'column_type': 'string'
}, {
'name': 'START',
'column_type': 'integer'
}, {
'name': 'END',
'column_type': 'integer'
}],
'description':
'CpG islands are associated ...'
})
def test_list_collections(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
user_id, user_key = self.get_new_user(epidb)
s, info = epidb.info("me", user_key)
self.assertSuccess(s, info)
self.assertEquals(info[0]["permission_level"], "LIST_COLLECTIONS")
self.modify_user_permission(epidb, user_id, "NONE")
s, info = epidb.info("me", user_key)
self.assertSuccess(s, info)
self.assertEquals(info[0]["permission_level"], "NONE")
s = epidb.info("me", user_key)
self.assertSuccess(s)
s = epidb.info("e1", user_key)
self.assertFailure(s)
s = epidb.info("p1", user_key)
self.assertFailure(s)
s = epidb.info("bs1", user_key)
self.assertFailure(s)
def test_biosource_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
res, bsid = epidb.add_biosource("K562", "desc1", {}, self.admin_key)
self.assertSuccess(res, bsid)
res, data = epidb.info(bsid, self.admin_key)
self.assertEqual(res, "okay")
self.assertEqual(data[0]['description'], "desc1")
self.assertEqual(data[0]['name'], "K562")
self.assertEqual(data[0]['user'], "test_admin")
self.assertEqual(data[0]['_id'], bsid)
def test_empty_no_permission_column_type(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
res, cid = epidb.create_column_type_category("PLUS_MINUS_DOT",
"Region strand: +, -, .",
["+", "-", "."],
self.admin_key)
s, (u_id, u_key) = epidb.add_user("user", "email", "institution",
self.admin_key)
self.assertSuccess(s)
s = epidb.modify_user_admin(u_id, "permission_level", "NONE",
self.admin_key)
self.assertSuccess(s)
info = epidb.info(cid, u_key)
self.assertEqual(info, [
'error',
'100100:Insufficient permission. Permission LIST_COLLECTIONS is required.'
])
info_e1 = epidb.info("e1", u_key)
self.assertEqual(info_e1, [
'error',
'100100:Insufficient permission. Permission LIST_COLLECTIONS is required.'
])
info_e2 = epidb.info("me", u_key)
self.assertEqual(info_e2, [
'okay',
[{
'name': 'user',
'institution': 'institution',
'id': 'u3',
'permission_level': 'NONE',
'type': 'user',
'email': 'email'
}]
])
def test_epigenetic_mark_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
res, emid = epidb.add_epigenetic_mark("Methylation", "DNA Methylation", {"category":"DNA Methylation"}, self.admin_key)
self.assertSuccess(res, emid)
res, data = epidb.info(emid, self.admin_key)
self.assertEqual(data[0]['name'], "Methylation")
self.assertEqual(data[0]['description'], "DNA Methylation")
self.assertEqual(data[0]['extra_metadata']['category'], "DNA Methylation")
self.assertEqual(data[0]['user'], "test_admin")
self.assertEqual(data[0]['_id'], emid)
def test_flank_genes(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
data = open("data/gtf/gencode.v23.basic.annotation_head.gtf").read()
(s, ss) = epidb.add_gene_model("Test One", "hg19",
"Test One Description", data, "GTF", {},
self.admin_key)
self.assertSuccess(s, ss)
(info, ss) = epidb.info(ss, self.admin_key)
print ss
(s, query_id) = epidb.select_genes([
"ENSG00000223972.5", "ENSG00000223972.5", "DDX11L1", "RP11-34P13.7"
], "", "Test One", None, None, None, self.admin_key)
(s, r_id) = epidb.get_regions(query_id, "CHROMOSOME,START,END,STRAND",
self.admin_key)
regions = self.get_regions_request(r_id)
self.assertEqual(regions,
"chr1\t11869\t14409\t+\nchr1\t89295\t133723\t-")
(s, f_id) = epidb.flank(query_id, -2500, 2000, False, self.admin_key)
(s, r_id) = epidb.get_regions(f_id, "CHROMOSOME,START,END,STRAND",
self.admin_key)
regions = self.get_regions_request(r_id)
self.assertEqual(regions,
"chr1\t9369\t11369\t+\nchr1\t86795\t88795\t-")
(s, f_id) = epidb.flank(query_id, -2500, 2000, True, self.admin_key)
(s, r_id) = epidb.get_regions(f_id, "CHROMOSOME,START,END,STRAND",
self.admin_key)
regions = self.get_regions_request(r_id)
self.assertEqual(regions,
'chr1\t9369\t11369\t+\nchr1\t134223\t136223\t-')
(s, f_id) = epidb.flank(query_id, 2500, 2000, False, self.admin_key)
(s, r_id) = epidb.get_regions(f_id, "CHROMOSOME,START,END,STRAND",
self.admin_key)
regions = self.get_regions_request(r_id)
self.assertEqual(regions,
"chr1\t16909\t18909\t+\nchr1\t136223\t138223\t-")
(s, f_id) = epidb.flank(query_id, 2500, 2000, True, self.admin_key)
(s, r_id) = epidb.get_regions(f_id, "CHROMOSOME,START,END,STRAND",
self.admin_key)
regions = self.get_regions_request(r_id)
self.assertEqual(regions,
'chr1\t16909\t18909\t+\nchr1\t84795\t86795\t-')
def test_column_types_search(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
res = epidb.create_column_type_simple("name", "description", "string", self.admin_key)
self.assertSuccess(res)
res = epidb.create_column_type_simple("string_column", "description", "string", self.admin_key)
self.assertSuccess(res)
res = epidb.create_column_type_simple("integer_column", "description", "integer", self.admin_key)
self.assertSuccess(res)
res = epidb.create_column_type_simple("double_column", "description", "double", self.admin_key)
self.assertSuccess(res)
res = epidb.create_column_type_range("score", "description", 0.0, 1.0, self.admin_key)
self.assertSuccess(res)
strand = ["+", "-"]
res = epidb.create_column_type_category("STRAND", "description", strand, self.admin_key)
self.assertSuccess(res)
(s, ss) = epidb.search("string_column", "column_types", self.admin_key)
(s, info) = epidb.info(ss[0][0], self.admin_key)
self.assertEqual(info[0], {'_id': 'ct31', 'description': 'description', 'type': 'column_type', 'name': 'string_column', 'column_type': 'string'})
(s, ss) = epidb.search("integer_column", "column_types", self.admin_key)
(s, info) = epidb.info(ss[0][0], self.admin_key)
self.assertEqual(info[0], {'_id': 'ct32', 'column_type': 'integer', 'description': 'description', 'type': 'column_type', 'name': 'integer_column'})
(s, ss) = epidb.search("double_column", "column_types", self.admin_key)
(s, info) = epidb.info(ss[0][0], self.admin_key)
self.assertEqual(info[0], {'_id': 'ct33', 'column_type': 'double', 'description': 'description', 'type': 'column_type', 'name': 'double_column'})
(s, ss) = epidb.search("score", "column_types", self.admin_key)
(s, info) = epidb.info(ss[0][0], self.admin_key)
self.assertEqual(info[0], {'_id': 'ct34','type': 'column_type', 'description': 'description', 'maximum': '1', 'minimum': '0', 'name': 'score', 'column_type': 'range'})
(s, ss) = epidb.search("STRAND", "column_types", self.admin_key)
(s, info) = epidb.info(ss[0][0], self.admin_key)
self.assertEqual(info[0], {'_id': 'ct35', 'type': 'column_type', 'description': 'description', 'name': 'STRAND', 'column_type': 'category', 'items': '+,-'})
def test_misc_formats(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
files = ["chr_s_e_name.bed", "chr_s_e_score.bed", "bed10.bed"]
print epidb.list_genomes(self.admin_key)
for f in files:
print f
content = open("data/bed/" + f).read()
res, q1 = epidb.input_regions("hg19", content, self.admin_key)
print epidb.info(q1, self.admin_key)
fmt = epidb.info(q1, self.admin_key)[1][0]['args']['format']
self.assertSuccess(res, q1)
print fmt
r, r1 = epidb.get_regions(q1, fmt, self.admin_key)
self.assertSuccess(r, r1)
for l in self.get_regions_request(r1).split("\n"):
print l
print len(l.split("\t"))
def test_load_bedgraph(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
sample_id = self.sample_ids[0]
regions_data = gzip.open("data/bedgraph/chr19.txt.gz").read()
# adding two experiments with the same data should work
res = epidb.add_experiment(
"S0022IH2.ERX300681.H3K36me3.bwa.GRCh38.20150528.bedgraph", "hg19",
"Methylation", sample_id, "tech1", "ENCODE", "desc1", regions_data,
"bedgraph", {"md5sum": "afd4af5afd5afd4af5afd5afd4af5afd5"},
self.admin_key)
self.assertSuccess(res)
(status, query_id) = epidb.select_regions(
"#afd4af5afd5afd4af5afd5afd4af5afd5", None, None, None, None, None,
"chr19", 49388217, 49417994, self.admin_key)
self.assertSuccess(status, query_id)
(status, input) = epidb.input_regions("hg19",
"chr19\t49388217\t49417994",
self.admin_key)
self.assertSuccess(status, input)
(status, query_overlap) = epidb.intersection(query_id, input,
self.admin_key)
self.assertSuccess(status, query_overlap)
(status, request_id) = epidb.get_regions(query_id,
"CHROMOSOME,START,END,VALUE",
self.admin_key)
self.assertSuccess(status, request_id)
(status,
overlap_request_id) = epidb.get_regions(query_id,
"CHROMOSOME,START,END,VALUE",
self.admin_key)
self.assertSuccess(status, overlap_request_id)
by_select = self.get_regions_request(request_id)
by_overlap = self.get_regions_request(overlap_request_id)
self.assertEqual(by_overlap, by_select)
self.assertTrue(len(by_select) > 0)
(status, info) = epidb.info("#afd4af5afd5afd4af5afd5afd4af5afd5",
self.admin_key)
self.assertEquals(info[0]["_id"], "e1")
def test_genome_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
genome_info = None
with open("data/genomes/hg19", 'r') as f:
genome_info = f.read().replace(",", "")
res, gid = epidb.add_genome("hg19", "Human genome 19", genome_info, self.admin_key)
self.assertSuccess(res, gid)
res, data = epidb.info(gid, self.admin_key)
self.assertEqual(data[0]['description'], "Human genome 19")
self.assertEqual(data[0]['name'], "hg19")
self.assertEqual(data[0]['user'], "test_admin")
self.assertEqual(data[0]['_id'], gid)
def test_sample_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
res, bsid = epidb.add_biosource("K562", "desc1", {}, self.admin_key)
self.assertSuccess(res, bsid)
res, sid = epidb.add_sample("K562", {"karyotype":"cancer","sex":"F"}, self.admin_key)
self.assertSuccess(res, sid)
res, data = epidb.info(sid, self.admin_key)
self.assertEqual(data[0]['biosource_name'], "K562")
self.assertEqual(data[0]['karyotype'], "cancer")
self.assertEqual(data[0]['sex'], "F")
self.assertEqual(data[0]['user'], "test_admin")
self.assertEqual(data[0]['_id'], sid)
def test_experiment_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
sample_id = self.sample_ids[0]
format = ",".join([
"CHROMOSOME",
"START",
"END",
"NAME",
"SCORE",
"STRAND",
"SIGNAL_VALUE",
"P_VALUE",
"Q_VALUE",
"PEAK"
])
eid = None
with open("data/bed/hg19_chr1_1.bed") as f:
res, eid = epidb.add_experiment("exp1", "hg19", "Methylation", sample_id, "tech1",
"ENCODE", "desc1", f.read(), format,
{"foo":"bar", "extra":"123"}, self.admin_key)
self.assertSuccess(res, eid)
res, data = epidb.info(eid, self.admin_key)
data[0]["upload_info"]["upload_start"] = '0'
data[0]["upload_info"]["upload_end"] = '0'
data[0]["upload_info"]["client_address"] = '0'
data[0]["upload_info"]["total_size"] = '0'
self.assertEqual(data[0], {'format': 'CHROMOSOME,START,END,NAME,SCORE,STRAND,SIGNAL_VALUE,P_VALUE,Q_VALUE,PEAK', 'extra_metadata': {'foo': 'bar', 'extra': '123'}, 'sample_info': {'karyotype': 'cancer', 'biosource_name': 'K562', 'karyotype': 'cancer', 'sex': 'F'}, 'technique': 'tech1', 'upload_info': {'total_size': '0', 'done': 'true', 'user': '******', 'upload_end': '0', 'upload_start': '0', 'client_address': '0'}, 'name': 'exp1', 'project': 'ENCODE', 'genome': 'hg19', 'sample_id': 's1', 'epigenetic_mark': 'Methylation', '_id': 'e1', 'type': 'experiment', 'columns': [{'name': 'CHROMOSOME', 'column_type': 'string'}, {'name': 'START', 'column_type': 'integer'}, {'name': 'END', 'column_type': 'integer'}, {'name': 'NAME', 'column_type': 'string'}, {'name': 'SCORE', 'column_type': 'double'}, {'name': 'STRAND', 'column_type':'category', 'items': '+,-,.'}, {'name': 'SIGNAL_VALUE', 'column_type': 'double'}, {'name': 'P_VALUE', 'column_type': 'double'}, {'name': 'Q_VALUE', 'column_type': 'double'}, {'name': 'PEAK', 'column_type': 'integer'}], 'description': 'desc1', 'data_type': 'peaks'})
self.assertEqual(res, 'okay')
self.assertEqual(data[0]['sample_id'], sample_id)
self.assertEqual(data[0]['description'], "desc1")
self.assertEqual(data[0]['extra_metadata'], {"foo":"bar", "extra":"123"})
self.assertEqual(data[0]['epigenetic_mark'], "Methylation")
self.assertEqual(data[0]['genome'], "hg19")
self.assertEqual(data[0]['name'], "exp1")
self.assertEqual(data[0]['project'], "ENCODE")
self.assertEqual(data[0]['technique'], "tech1")
self.assertEqual(data[0]['upload_info']['user'], "test_admin")
self.assertEqual(data[0]['format'], "CHROMOSOME,START,END,NAME,SCORE,STRAND,SIGNAL_VALUE,P_VALUE,Q_VALUE,PEAK")
self.assertEqual(data[0]['_id'], eid)
def test_annotation_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
aid = None
with open("data/cpgIslandExt.txt") as f:
res, aid = epidb.add_annotation("Cpg Islands", "hg19", "CpG islands are associated ...",
f.read(), "", {"url":"genome.ucsc.edu...", "meta":"data"},
self.admin_key)
self.assertSuccess(res, aid)
res, data = epidb.info(aid, self.admin_key)
self.assertEqual(res, 'okay')
self.assertEqual(data[0]['name'], "Cpg Islands")
self.assertEqual(data[0]['description'], "CpG islands are associated ...")
self.assertEqual(data[0]['genome'], "hg19")
self.assertEqual(data[0]['extra_metadata'], {"url":"genome.ucsc.edu...", "meta":"data"})
self.assertEqual(data[0]['upload_info']['user'], "test_admin")
self.assertEqual(data[0]['format'], "CHROMOSOME,START,END")
self.assertEqual(data[0]['_id'], aid)
def test_experiment_sets(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_full(epidb)
epidb.list_experiments
(s, ees) = epidb.list_experiments("", "", "", "", "", "", "",
self.admin_key)
(s, names) = epidb.extract_names(ees)
print names
print
(s, es1) = epidb.create_experiments_set("Test 1", "set test one", True,
names, self.admin_key)
print s
print es1
(s, info_es1) = epidb.info(es1, self.admin_key)
print info_es1
def test_janitor(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base()
# Test parameters
s, v = epidb.modify_user_admin(None, "old_request_age_in_sec", None,
self.admin_key)
self.assertEqual(v, ['old_request_age_in_sec', '2592000'])
s, v = epidb.modify_user_admin(None, "old_request_age_in_sec", "-1",
self.admin_key)
self.assertEqual(v, ['old_request_age_in_sec', '2592000'])
s, v = epidb.modify_user_admin(None, "janitor_periodicity", None,
self.admin_key)
self.assertEqual(v, ['janitor_periodicity', '60'])
s, v = epidb.modify_user_admin(None, "janitor_periodicity", "-1",
self.admin_key)
self.assertEqual(v, ['janitor_periodicity', '60'])
# Do a simple request
res, qid = epidb.tiling_regions(1000000, "hg19",
["chr15", "chrX", "chr3"],
self.admin_key)
self.assertSuccess(res, qid)
res, req = epidb.get_regions(qid, "CHROMOSOME,START,END",
self.admin_key)
self.assertSuccess(res, req)
regions = self.get_regions_request(req)
chr3_tiles = 198022430 / 1000000
chr15_tiles = 102531392 / 1000000
chrX_tiles = 155270560 / 1000000
self.assertEqual(len(regions.strip().split('\n')),
chr3_tiles + chr15_tiles + chrX_tiles)
# Check removal
s, m = epidb.modify_user_admin(None, "janitor_periodicity", "1",
self.admin_key)
s, v = epidb.modify_user_admin(None, "janitor_periodicity", None,
self.admin_key)
self.assertEqual(v, ['janitor_periodicity', '1'])
s, m = epidb.modify_user_admin(None, "old_request_age_in_sec", "3",
self.admin_key)
s, v = epidb.modify_user_admin(None, "old_request_age_in_sec", None,
self.admin_key)
self.assertEqual(v, ['old_request_age_in_sec', '3'])
time.sleep(4)
s, info = epidb.info(req, self.admin_key)
self.assertEqual(info[0]["state"], "cleared")
# Check reprocessing by re-requesting the data
s, m = epidb.get_request_data(req, self.admin_key)
self.assertFailure(s, m)
self.assertEqual(
m,
'Request ID r1 was cleared. We are going to reprocess this request. Please, check its status.'
)
s, info = epidb.info(req, self.admin_key)
self.assertEqual(info[0]["state"], "reprocess")
regions = self.get_regions_request(req)
chr3_tiles = 198022430 / 1000000
chr15_tiles = 102531392 / 1000000
chrX_tiles = 155270560 / 1000000
self.assertEqual(len(regions.strip().split('\n')),
chr3_tiles + chr15_tiles + chrX_tiles)
# Check reprocessing by making performing the request again
s, m = epidb.modify_user_admin(None, "janitor_periodicity", "1",
self.admin_key)
time.sleep(1)
s, info = epidb.info(req, self.admin_key)
self.assertEqual(info[0]["state"], "done")
time.sleep(3)
s, info = epidb.info(req, self.admin_key)
self.assertEqual(info[0]["state"], "cleared")
s, m = epidb.modify_user_admin(None, "janitor_periodicity", "10",
self.admin_key)
res, req = epidb.get_regions(qid, "CHROMOSOME,START,END",
self.admin_key)
s, info = epidb.info(req, self.admin_key)
self.assertEqual(info[0]["state"], "reprocess")
regions = self.get_regions_request(req)
chr3_tiles = 198022430 / 1000000
chr15_tiles = 102531392 / 1000000
chrX_tiles = 155270560 / 1000000
def test_gene_expression(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
(s, project) = epidb.add_project("DEEP", "Deutsche Epigenom",
self.admin_key)
self.assertSuccess(s, project)
data = gzip.open("data/fpkm/small_1.fpkm_tracking.gz").read()
(s, gene_expression) = epidb.add_expression("gene", "s2", 1, data,
"cufflinks", "DEEP", None,
self.admin_key)
self.assertSuccess(s, gene_expression)
data = gzip.open("data/fpkm/small_2.fpkm_tracking.gz").read()
(s, gene_expression) = epidb.add_expression("gene", "s2", 2, data,
"cufflinks", "DEEP", None,
self.admin_key)
self.assertSuccess(s, gene_expression)
data = gzip.open("data/fpkm/small_3.fpkm_tracking.gz").read()
(s, gene_expression) = epidb.add_expression("gene", "s2", 44, data,
"cufflinks", "DEEP", None,
self.admin_key)
self.assertSuccess(s, gene_expression)
(s, gex) = epidb.list_expressions("gene", "s1", None, None,
self.admin_key)
self.assertEquals(gex, [])
(s, gex) = epidb.list_expressions("gene", "s2", None, None,
self.admin_key)
self.assertEquals(gex, [['gx1', ''], ['gx2', ''], ['gx3', '']])
(s, gex) = epidb.list_expressions("gene", "s2", [1, 2], None,
self.admin_key)
self.assertEquals(gex, [['gx1', ''], ['gx2', '']])
(s, gex) = epidb.list_expressions("gene", "s2", 44, None,
self.admin_key)
self.assertEquals(gex, [['gx3', '']])
(s, gex) = epidb.list_expressions("gene", None, 1, "DEEP",
self.admin_key)
self.assertEquals(gex, [['gx1', '']])
data = gzip.open(
"data/fpkm/51_Hf03_BlTN_Ct_mRNA_M_1.LXPv1.20150708_genes.fpkm_tracking.gz"
).read()
(s, gene_expression) = epidb.add_expression("gene", "s1", 1, data,
"cufflinks", "ENCODE",
None, self.admin_key)
self.assertSuccess(s, gene_expression)
(s, gex) = epidb.list_expressions("gene", None, None, None,
self.admin_key)
self.assertEquals(gex,
[['gx1', ''], ['gx2', ''], ['gx3', ''], ['gx4', '']])
(s, gex) = epidb.list_expressions("gene", "s1", 1, None,
self.admin_key)
self.assertEquals(gex, [['gx4', '']])
(s, gex) = epidb.list_expressions("gene", None, None, "ENCODE",
self.admin_key)
self.assertEquals(gex, [['gx4', '']])
(s, gex) = epidb.list_expressions("gene", ["s1", "s2"], 1, None,
self.admin_key)
self.assertEquals(gex, [['gx1', ''], ['gx4', '']])
(s, gex) = epidb.list_expressions("gene", ["s1", "s2"], 2, None,
self.admin_key)
self.assertEquals(gex, [['gx2', '']])
(s, gex) = epidb.list_expressions("gene", None, 1, "ENCODE",
self.admin_key)
self.assertEquals(gex, [['gx4', '']])
s, user = epidb.add_user("user", "email", "institution",
self.admin_key)
(user_id, user_key) = user
self.assertSuccess(s)
(s, ss) = epidb.modify_user_admin(user_id, "permission_level",
"GET_DATA", self.admin_key)
self.assertSuccess(s, ss)
(s, gex) = epidb.list_expressions("gene", None, None, None, user_key)
self.assertEquals(gex, [])
(s, gex) = epidb.list_expressions("gene", "s1", 1, None, user_key)
self.assertEquals(gex, [])
(s, gex) = epidb.list_expressions("gene", None, None, "ENCODE",
user_key)
self.assertEquals(gex, "107000:Project 'ENCODE' does not exist.")
(s, info) = epidb.info(gene_expression, self.admin_key)
self.assertEquals(
info[0], {
'format':
'TRACKING_ID,GENE_ID,GENE_SHORT_NAME,FPKM,FPKM_CONF_LO,FPKM_CONF_HI,FPKM_STATUS',
'sample_info': {
'biosource_name': 'K562',
'karyotype': 'cancer',
'sex': 'F'
},
'content_format':
'cufflinks',
'total_genes':
57910,
'replica':
1,
'sample_id':
's1',
'_id':
'gx4',
'extra_metadata': {},
'columns': [{
'name': 'TRACKING_ID',
'column_type': 'string'
}, {
'name': 'GENE_ID',
'column_type': 'string'
}, {
'name': 'GENE_SHORT_NAME',
'column_type': 'string'
}, {
'name': 'FPKM',
'column_type': 'double'
}, {
'name': 'FPKM_CONF_LO',
'column_type': 'double'
}, {
'name': 'FPKM_CONF_HI',
'column_type': 'double'
}, {
'name': 'FPKM_STATUS',
'column_type': 'string'
}]
})
data = gzip.open(
"data/grape2/SP8-TH91.gene_quantification.rsem_grape2_crg.GRCh38.20150622.results.txt.gz"
).read()
(s, gene_expression) = epidb.add_expression("gene", "s1", 1, data,
"grape2", "ENCODE", None,
self.admin_key)
self.assertEquals(
gene_expression,
"131001:A Expression of the type 'gene' with sample_id 's1' and replica '1' already exists."
)
(s, gene_expression) = epidb.add_expression("gene", "s1", 2, data,
"grape2", "ENCODE", None,
self.admin_key)
self.assertSuccess(s, gene_expression)
data = gzip.open(
"data/gtf/gencode.v19.annotation.ONLY_GENES.gtf.gz").read()
(s, ss) = epidb.add_gene_model("gencode v19", "hg19",
"Test One Description", data, "GTF", {},
self.admin_key)
self.assertSuccess(s, ss)
(status, gx_query) = epidb.select_expressions("gene", "s1", 2,
"ENSG00000000003.13",
"ENCODE", "gencode v19",
self.admin_key)
self.assertSuccess(status, gx_query)
status, info = epidb.info(gx_query, user_key)
(status, r_id) = epidb.get_regions(
gx_query,
"CHROMOSOME,START,END,@STRAND,GENE_ID,TRANSCRIPT_IDS,LENGTH,EFFECTIVE_LENGTH,EXPECTED_COUNT,TPM,FPKM,POSTERIOR_MEAN_COUNT,POSTERIOR_STANDARD_DEVIATION_OF_COUNT,PME_TPM,PME_FPKM,TPM_CI_LOWER_BOUND,TPM_CI_UPPER_BOUND,FPKM_CI_LOWER_BOUND,FPKM_CI_UPPER_BOUND",
self.admin_key)
self.assertSuccess(status, r_id)
regions = self.get_regions_request(r_id)
self.assertEquals(
regions,
"chrX\t99883667\t99894988\t-\tENSG00000000003.13\tENSG00000000003.13\t2025\t1855.4301\t161.0000\t1.0000\t2.1300\t161.0000\t0.0000\t1.0500\t2.2700\t0.8742\t1.2451\t1.8882\t2.6879"
)
(status, gx_query) = epidb.select_expressions("gene", "s1", 2,
"ENSG00000000003.13",
"ENCODE", "gencode v19",
self.admin_key)
self.assertSuccess(status, gx_query)
status, info = epidb.info(gx_query, user_key)
(status, r_id) = epidb.get_regions(
gx_query,
"GENE_ID,TRANSCRIPT_IDS,LENGTH,EFFECTIVE_LENGTH,EXPECTED_COUNT,TPM,FPKM,POSTERIOR_MEAN_COUNT,POSTERIOR_STANDARD_DEVIATION_OF_COUNT,PME_TPM,PME_FPKM,TPM_CI_LOWER_BOUND,TPM_CI_UPPER_BOUND,FPKM_CI_LOWER_BOUND,FPKM_CI_UPPER_BOUND",
self.admin_key)
self.assertSuccess(status, r_id)
regions = self.get_regions_request(r_id)
self.assertEquals(
regions,
"ENSG00000000003.13\tENSG00000000003.13\t2025\t1855.4301\t161.0000\t1.0000\t2.1300\t161.0000\t0.0000\t1.0500\t2.2700\t0.8742\t1.2451\t1.8882\t2.6879"
)
(status, gx_query) = epidb.select_expressions("gene", "s1", 1,
"OR4G11P", "ENCODE",
"gencode v19",
self.admin_key)
self.assertSuccess(status, gx_query)
status, info = epidb.info("gx1", user_key)
(status, r_id) = epidb.get_regions(gx_query, info[0]["format"],
self.admin_key)
self.assertSuccess(status, r_id)
regions = self.get_regions_request(r_id)
self.assertEquals(
regions,
"ENSG00000240361.1\tENSG00000240361.1\tOR4G11P\t0.0000\t0.0000\t0.0000\tOK"
)
(status, gx_query) = epidb.select_expressions(
"gene", "s1", 1,
['CCR1', 'CD164', 'CD1D', 'CD2', 'CD34', 'CD3G', 'CD44'], "ENCODE",
"gencode v19", self.admin_key)
self.assertSuccess(status, gx_query)
status, info = epidb.info("gx1", user_key)
(status, r_id) = epidb.get_regions(gx_query, info[0]["format"],
self.admin_key)
self.assertSuccess(status, r_id)
regions_a = self.get_regions_request(r_id)
excepted = "ENSG00000135535.10\tENSG00000135535.10\tCD164\t101.3820\t98.8947\t103.8680\tOK\nENSG00000026508.12\tENSG00000026508.12\tCD44\t193.4920\t189.4020\t197.5830\tOK\nENSG00000160654.5\tENSG00000160654.5\tCD3G\t53.0051\t51.4405\t54.5696\tOK\nENSG00000163823.3\tENSG00000163823.3\tCCR1\t0.0201\t0.0000\t0.0433\tOK\nENSG00000116824.4\tENSG00000116824.4\tCD2\t90.0146\t87.9630\t92.0661\tOK\nENSG00000158473.6\tENSG00000158473.6\tCD1D\t0.0241\t0.0000\t0.0519\tOK\nENSG00000174059.12\tENSG00000174059.12\tCD34\t0.0000\t0.0000\t0.0000\tOK"
lexp = excepted.split("\n")
lresult = regions_a.split("\n")
self.assertEquals(len(lresult), len(lexp))
for l in lresult:
self.assertTrue(l in lexp)
(status, gx_query) = epidb.select_expressions("gene", "s1", 1, 'CCR1',
"ENCODE", "gencode v19",
self.admin_key)
self.assertSuccess(status, gx_query)
status, info = epidb.info("gx1", user_key)
(status, r_id) = epidb.get_regions(gx_query, info[0]["format"],
self.admin_key)
self.assertSuccess(status, r_id)
regions = self.get_regions_request(r_id)
self.assertEquals(
regions,
"ENSG00000163823.3\tENSG00000163823.3\tCCR1\t0.0201\t0.0000\t0.0433\tOK"
)
q1 = gx_query
(status, gx_query) = epidb.select_expressions("gene", "s1", 1, 'CD164',
"ENCODE", "gencode v19",
self.admin_key)
self.assertSuccess(status, gx_query)
status, info = epidb.info("gx1", user_key)
(status, r_id) = epidb.get_regions(gx_query, info[0]["format"],
self.admin_key)
self.assertSuccess(status, r_id)
regions = self.get_regions_request(r_id)
self.assertEquals(
regions,
"ENSG00000135535.10\tENSG00000135535.10\tCD164\t101.3820\t98.8947\t103.8680\tOK"
)
self.assertTrue(q1 != gx_query)
(s, info) = epidb.info(ss, self.admin_key)
self.assertEquals(
info[0], {
'total_genes': 57820,
'_id': 'gs1',
'genome': 'hg19',
'description': 'Test One Description',
'format': 'GTF',
'name': 'gencode v19'
})
(status, gene_info) = epidb.info("gn1", self.admin_key)
self.assertEquals(
gene_info[0], {
'transcript_status': 'KNOWN',
'gene_name': 'DDX11L1',
'gene_type': 'pseudogene',
'end': 14412,
'source': 'HAVANA',
'frame': '.',
'level': '2',
'gene_id': 'ENSG00000223972.4',
'start': 11869,
'transcript_id': 'ENSG00000223972.4',
'score': 0.0,
'strand': '+',
'havana_gene': 'OTTHUMG00000000961.2',
'transcript_name': 'DDX11L1',
'_id': 'gn1',
'gene_status': 'KNOWN',
'transcript_type': 'pseudogene',
'chromosome': 'chr1'
})
(status, query) = epidb.select_expressions("gene", "s1",
[1, 5, 10, 122], None,
"ENCODE", "gencode v19",
self.admin_key)
query_one = query
self.assertSuccess(status, query)
(status, filtered) = epidb.filter_regions(query, "FPKM_STATUS", "!=",
"OK", "string",
self.admin_key)
self.assertSuccess(status, filtered)
(status, filtered_chr) = epidb.filter_regions(filtered, "CHROMOSOME",
"==", "chr21", "string",
self.admin_key)
self.assertSuccess(status, filtered_chr)
(status, r_id) = epidb.get_regions(
filtered_chr, "GENE_ID,FPKM_STATUS,@SAMPLE_ID,@BIOSOURCE",
self.admin_key)
self.assertSuccess(status, r_id)
regions = self.get_regions_request(r_id)
self.assertEquals(
regions,
"ENSG00000240755.1\tLOWDATA\ts1\tK562\nENSG00000256386.1\tLOWDATA\ts1\tK562\nENSG00000198743.5\tLOWDATA\ts1\tK562\nENSG00000267937.1\tLOWDATA\ts1\tK562\nENSG00000238556.1\tLOWDATA\ts1\tK562\nENSG00000255902.1\tLOWDATA\ts1\tK562\nENSG00000266692.1\tLOWDATA\ts1\tK562"
)
(status, query) = epidb.select_expressions("gene", "s1",
[1, 5, 10, 122], None, "",
"gencode v19", user_key)
self.assertSuccess(status, query)
(status, filtered) = epidb.filter_regions(query, "FPKM_STATUS", "!=",
"OK", "string", user_key)
self.assertSuccess(status, filtered)
(status, filtered_chr) = epidb.filter_regions(filtered, "CHROMOSOME",
"==", "chr21", "string",
user_key)
self.assertSuccess(status, filtered_chr)
(status,
req) = epidb.get_regions(filtered_chr,
"GENE_ID,FPKM_STATUS,@SAMPLE_ID,@BIOSOURCE",
user_key)
self.assertSuccess(status, r_id)
(s, ss) = epidb.info(req, user_key)
while ss[0]["state"] != "done":
time.sleep(1)
(s, ss) = epidb.info(req, user_key)
s, regions = epidb.get_request_data(req, user_key)
self.assertEquals(
regions,
"ENSG00000240755.1\tLOWDATA\ts1\tK562\nENSG00000256386.1\tLOWDATA\ts1\tK562\nENSG00000198743.5\tLOWDATA\ts1\tK562\nENSG00000267937.1\tLOWDATA\ts1\tK562\nENSG00000238556.1\tLOWDATA\ts1\tK562\nENSG00000255902.1\tLOWDATA\ts1\tK562\nENSG00000266692.1\tLOWDATA\ts1\tK562"
)
def test_invalid_format_size(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
aid1 = self.insert_annotation(epidb, "Cpg Islands All Fields")
(s, m) = epidb.create_column_type_simple("CPG_ISLAND_NAME", "",
"string", self.admin_key)
self.assertSuccess(s, m)
(s, clone_id) = epidb.clone_dataset(
aid1, "New CpG Islands", "", "", "", "", "",
"CHROMOSOME,START,END,CPG_ISLAND_NAME,LENGTH,NUM_CPG,NUM_GC,PER_CPG,PER_CG,OBS_EXP",
{"new": "true"}, self.admin_key)
self.assertSuccess(s, clone_id)
s, info = epidb.info(clone_id, self.admin_key)
info[0]['upload_info']['upload_end'] = '0'
info[0]['upload_info']['upload_start'] = '0'
info[0]['upload_info']['total_size'] = '0'
info[0]['upload_info']['client_address'] = '0'
self.assertEqual(
info[0], {
'description':
'CpG islands are associated ... (all fields)',
'format':
'CHROMOSOME,START,END,CPG_ISLAND_NAME,LENGTH,NUM_CPG,NUM_GC,PER_CPG,PER_CG,OBS_EXP',
'extra_metadata': {
'new': 'true'
},
'upload_info': {
'total_size': '0',
'content_format': 'peaks',
'done': 'true',
'user': '******',
'upload_end': '0',
'upload_start': '0',
'client_address': '0'
},
'genome':
'hg19',
'_id':
'a4',
'type':
'annotation',
'columns': [{
'name': 'CHROMOSOME',
'column_type': 'string'
}, {
'name': 'START',
'column_type': 'integer'
}, {
'name': 'END',
'column_type': 'integer'
}, {
'name': 'CPG_ISLAND_NAME',
'column_type': 'string'
}, {
'name': 'LENGTH',
'column_type': 'integer'
}, {
'name': 'NUM_CPG',
'column_type': 'integer'
}, {
'name': 'NUM_GC',
'column_type': 'integer'
}, {
'name': 'PER_CPG',
'column_type': 'double'
}, {
'name': 'PER_CG',
'column_type': 'double'
}, {
'name': 'OBS_EXP',
'column_type': 'double'
}],
'name':
'New CpG Islands'
})
def test_clone_experiment(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init_base(epidb)
eid1 = self.insert_experiment(epidb, "hg18_chr1_1")
(s, info_original) = epidb.info(eid1, self.admin_key)
info_original[0]['upload_info']['upload_end'] = '0'
info_original[0]['upload_info']['upload_start'] = '0'
info_original[0]['upload_info']['client_address'] = '0'
info_original[0]['upload_info']['total_size'] = '0'
self.assertEqual(
info_original[0], {
'description':
'desc1',
'data_type':
'peaks',
'format':
'CHROMOSOME,START,END,NAME,SCORE,STRAND,SIGNAL_VALUE,P_VALUE,Q_VALUE,PEAK',
'sample_info': {
'biosource_name': 'K562',
'karyotype': 'cancer',
'sex': 'F'
},
'technique':
'tech1',
'upload_info': {
'total_size': '0',
'done': 'true',
'user': '******',
'upload_end': '0',
'upload_start': '0',
'client_address': '0'
},
'project':
'ENCODE',
'genome':
'hg18',
'sample_id':
's1',
'epigenetic_mark':
'Methylation',
'_id':
'e1',
'type':
'experiment',
'columns': [{
'name': 'CHROMOSOME',
'column_type': 'string'
}, {
'name': 'START',
'column_type': 'integer'
}, {
'name': 'END',
'column_type': 'integer'
}, {
'name': 'NAME',
'column_type': 'string'
}, {
'name': 'SCORE',
'column_type': 'double'
}, {
'name': 'STRAND',
'column_type': 'category',
'items': '+,-,.',
}, {
'name': 'SIGNAL_VALUE',
'column_type': 'double'
}, {
'name': 'P_VALUE',
'column_type': 'double'
}, {
'name': 'Q_VALUE',
'column_type': 'double'
}, {
'name': 'PEAK',
'column_type': 'integer'
}],
'name':
'hg18_chr1_1'
})
(s, id_clone_plus) = epidb.clone_dataset(
eid1, "new experiment clone", "", "", "", "",
"getting only the default values", "", {
"new data": "true",
"cool": "a lot"
}, self.admin_key)
self.assertSuccess(s, id_clone_plus)
(s, info_clone_plus) = epidb.info(id_clone_plus, self.admin_key)
info_clone_plus[0]['upload_info']['upload_start'] = '0'
info_clone_plus[0]['upload_info']['upload_end'] = '0'
info_clone_plus[0]['upload_info']['total_size'] = '0'
info_clone_plus[0]['upload_info']['client_address'] = '0'
self.assertEqual(
info_clone_plus[0], {
'description':
'getting only the default values',
'data_type':
'peaks',
'format':
'CHROMOSOME,START,END,NAME,SCORE,STRAND,SIGNAL_VALUE,P_VALUE,Q_VALUE,PEAK',
'extra_metadata': {
'new data': 'true',
'cool': 'a lot'
},
'sample_info': {
'biosource_name': 'K562',
'karyotype': 'cancer',
'sex': 'F'
},
'technique':
'tech1',
'upload_info': {
'total_size': '0',
'done': 'true',
'user': '******',
'upload_end': '0',
'upload_start': '0',
'client_address': '0'
},
'project':
'ENCODE',
'genome':
'hg18',
'sample_id':
's1',
'epigenetic_mark':
'Methylation',
'_id':
'e2',
'type':
'experiment',
'columns': [{
'name': 'CHROMOSOME',
'column_type': 'string'
}, {
'name': 'START',
'column_type': 'integer'
}, {
'name': 'END',
'column_type': 'integer'
}, {
'name': 'NAME',
'column_type': 'string'
}, {
'name': 'SCORE',
'column_type': 'double'
}, {
'name': 'STRAND',
'column_type': 'category',
'items': '+,-,.',
}, {
'name': 'SIGNAL_VALUE',
'column_type': 'double'
}, {
'name': 'P_VALUE',
'column_type': 'double'
}, {
'name': 'Q_VALUE',
'column_type': 'double'
}, {
'name': 'PEAK',
'column_type': 'integer'
}],
'name':
'new experiment clone'
})
(s, _id_clone_same) = epidb.clone_dataset(
eid1, "clone of new experiment", "", "", "", "", "",
"CHROMOSOME,START,END,NAME,SCORE,STRAND,SIGNAL_VALUE,P_VALUE,Q_VALUE,PEAK",
{}, self.admin_key)
self.assertSuccess(s, _id_clone_same)
(s, info_clone) = epidb.info(_id_clone_same, self.admin_key)
self.assertSuccess(s, info_clone)
info_clone[0]['upload_info']['upload_start'] = '0'
info_clone[0]['upload_info']['upload_end'] = '0'
info_clone[0]['upload_info']['total_size'] = '0'
info_clone[0]['upload_info']['client_address'] = '0'
self.assertEqual(
info_clone[0], {
'data_type':
'peaks',
'description':
'desc1',
'format':
'CHROMOSOME,START,END,NAME,SCORE,STRAND,SIGNAL_VALUE,P_VALUE,Q_VALUE,PEAK',
'sample_info': {
'biosource_name': 'K562',
'karyotype': 'cancer',
'sex': 'F'
},
'technique':
'tech1',
'upload_info': {
'total_size': '0',
'done': 'true',
'user': '******',
'upload_end': '0',
'upload_start': '0',
'client_address': '0'
},
'project':
'ENCODE',
'genome':
'hg18',
'sample_id':
's1',
'epigenetic_mark':
'Methylation',
'_id':
'e3',
'type':
'experiment',
'columns': [{
'name': 'CHROMOSOME',
'column_type': 'string'
}, {
'name': 'START',
'column_type': 'integer'
}, {
'name': 'END',
'column_type': 'integer'
}, {
'name': 'NAME',
'column_type': 'string'
}, {
'name': 'SCORE',
'column_type': 'double'
}, {
'name': 'STRAND',
'column_type': 'category',
'items': '+,-,.',
'name': 'STRAND'
}, {
'name': 'SIGNAL_VALUE',
'column_type': 'double'
}, {
'name': 'P_VALUE',
'column_type': 'double'
}, {
'name': 'Q_VALUE',
'column_type': 'double'
}, {
'name': 'PEAK',
'column_type': 'integer'
}],
'name':
'clone of new experiment'
})
def test_genome_info(self):
epidb = DeepBlueClient(address="localhost", port=31415)
self.init(epidb)
hg18_genome_info = None
with open("data/genomes/hg18", 'r') as f:
hg18_genome_info = f.read().replace(",", "")
res = epidb.add_genome("hg18", "Human genome 18", hg18_genome_info,
self.admin_key)
self.assertSuccess(res)
info = [{
'chromosomes': [{
'name': 'chr1',
'size': 247249719
}, {
'name': 'chr1_random',
'size': 1663265
}, {
'name': 'chr10',
'size': 135374737
}, {
'name': 'chr10_random',
'size': 113275
}, {
'name': 'chr11',
'size': 134452384
}, {
'name': 'chr11_random',
'size': 215294
}, {
'name': 'chr12',
'size': 132349534
}, {
'name': 'chr13',
'size': 114142980
}, {
'name': 'chr13_random',
'size': 186858
}, {
'name': 'chr14',
'size': 106368585
}, {
'name': 'chr15',
'size': 100338915
}, {
'name': 'chr15_random',
'size': 784346
}, {
'name': 'chr16',
'size': 88827254
}, {
'name': 'chr16_random',
'size': 105485
}, {
'name': 'chr17',
'size': 78774742
}, {
'name': 'chr17_random',
'size': 2617613
}, {
'name': 'chr18',
'size': 76117153
}, {
'name': 'chr18_random',
'size': 4262
}, {
'name': 'chr19',
'size': 63811651
}, {
'name': 'chr19_random',
'size': 301858
}, {
'name': 'chr2',
'size': 242951149
}, {
'name': 'chr2_random',
'size': 185571
}, {
'name': 'chr20',
'size': 62435964
}, {
'name': 'chr21',
'size': 46944323
}, {
'name': 'chr21_random',
'size': 1679693
}, {
'name': 'chr22',
'size': 49691432
}, {
'name': 'chr22_random',
'size': 257318
}, {
'name': 'chr22_h2_hap1',
'size': 63661
}, {
'name': 'chr3',
'size': 199501827
}, {
'name': 'chr3_random',
'size': 749256
}, {
'name': 'chr4',
'size': 191273063
}, {
'name': 'chr4_random',
'size': 842648
}, {
'name': 'chr5',
'size': 180857866
}, {
'name': 'chr5_random',
'size': 143687
}, {
'name': 'chr5_h2_hap1',
'size': 1794870
}, {
'name': 'chr6',
'size': 170899992
}, {
'name': 'chr6_random',
'size': 1875562
}, {
'name': 'chr6_cox_hap1',
'size': 4731698
}, {
'name': 'chr6_qbl_hap2',
'size': 4565931
}, {
'name': 'chr7',
'size': 158821424
}, {
'name': 'chr7_random',
'size': 549659
}, {
'name': 'chr8',
'size': 146274826
}, {
'name': 'chr8_random',
'size': 943810
}, {
'name': 'chr9',
'size': 140273252
}, {
'name': 'chr9_random',
'size': 1146434
}, {
'name': 'chrM',
'size': 16571
}, {
'name': 'chrX',
'size': 154913754
}, {
'name': 'chrX_random',
'size': 1719168
}, {
'name': 'chrY',
'size': 57772954
}],
'description':
'Human genome 18',
'user':
'******',
'_id':
'g1',
'type':
'genome',
'name':
'hg18'
}]
s, info_answer = epidb.info("g1", self.admin_key)
self.assertEqual(info_answer, info)
