def gen_pdm_from_indfile(ont_url, outfile):
"""Reads an owl file from ont_url; Writes a JSON file (outfile) of
types and annotations on individuals in the file.
JSON structure:
id:
label: string
def: string
types:
- isAnonymous:boolean;
- relId:URI_string;
- objectId:URI_string.
"""
ont = Brain()
ont.learn(ont_url)
axioms = {}
if ont.knowsClass("CARO_0030002"):
axioms.update(gen_pdm(ont, ont.getInstances("CARO_0030002", 0), "CARO_0030002")) # expression_patterns
if ont.knowsClass("FBbt_00005106"):
axioms.update(gen_pdm(ont, ont.getInstances("FBbt_00005106", 0), "FBbt_00005106")) # neurons
if ont.knowsClass("FBbt_00007683"):
axioms.update(gen_pdm(ont, ont.getInstances("FBbt_00007683", 0), "FBbt_00007683")) # clones
jfile = open(outfile, "w")
jfile.write(json.dumps(axioms, sort_keys=True, indent=4))
ont.sleep()
def __main__():
ont = Brain()
ont.learn(sys.argv[1])
qtab = tab("./", "queries.tsv")
for r in qtab.tab:
q = Query(r, ont)
q.qtest()
ont.sleep()
import sys
"""Runs verification tests on abstract patterns and generates markdown docs.
1st ARG specifies path to input/output files.
Second ARG specifies ontology file to use in validation."""
def load_json_from_file(path):
json_file = open(path, "r")
json_string = json_file.read()
json_file.close()
return json.loads(json_string)
# Testing abstract pattern validation and documentation
o = Brain()
o.learn(sys.argv[2]) # Running with local file for now.
# Switch this to specify path as argv
json_files = glob.glob(sys.argv[1] + "*.json") # Note - glob returns full file path
for f in json_files:
p = load_json_from_file(f)
m = re.search("(.+).json", f)
pattern_name = m.group(1)
print "Processing %s" % pattern_name
ap = pattern.abstract_pattern(p, o)
md = open(pattern_name + ".md", "w")
#print ap.gen_markdown_doc()
md.write(ap.gen_markdown_doc())
md.close()
o.sleep()
if "domainId" in term["domainData"]:
term["domainData"]["domainId"] = oboid_domId[oboid] # Terns that didn't formerly have domainId will not, at the point
else:
term["domainData"] = {"domainColour": [0,128,128,127],"domainId": oboid_domId[oboid],"domainSelected": "false"} # Setting default colour - will need to fix.
else:
if "domainId" in term["domainData"]:
term["domainData"]["domainId"] = '' # Remove old domain_id, if present.
owl_id = re.sub(':','_',oboid)
name = '';
if fbbt.knowsClass(owl_id):
name = fbbt.getLabel(owl_id)
print "Ignoring %s %s as , according to the mapping file, it is not a painted domain." % (oboid, name)
new_tc.append(term)
# Adding records for any new terms
for oboid, domid in oboid_domId.items():
if oboid not in known_term_list:
new_tc.append({"domainData":{"domainColour": [0,128,128,127],"domainId": domid,"domainSelected": "false"}, "extId": [oboid],"nodeState": {"open": "false", "selected": "false"} }) # Anything generated here will need a new nodeId.
update_names(new_tc, fbbt)
fbbt.sleep()
write_json(new_tc, "../json/treeContent_JFRC_BN_final.jso")
#!/usr/bin/env jython -J-Xmx3000m
import sys
from uk.ac.ebi.brain.core import Brain
sys.path.append('../mod')
from lmb_fc_tools import get_con, owlDbOnt
con = get_con(sys.argv[1], sys.argv[2])
obo = "http://purl.obolibrary.org/obo/"
vfb = obo + "fbbt/vfb/"
paths = [obo + "fbbt/fbbt-simple.owl",
obo + "so.owl",
vfb + "fb_features.owl",
obo + "ro.owl",
vfb + "vfb_ext.owl"
]
# Could be done with one big brain file in memory, but would require lots of ram to run
for p in paths:
b = Brain()
b.learn(p)
od = owlDbOnt(con, b)
od.update_labels()
b.sleep()
con.close()
# baseURI = ''
# for d in dc:
# baseURI = d['baseURI']
# cursor.close()
vfb_ind = Brain('http://www.virtualflybrain.org/owl/', 'http://www.virtualflybrain.org/owl/' + 'flycircuit_plus.owl') # Adding IRI manually for now.
# Setup ontologies
addOboAnnotationProperties(vfb_ind)
addVFBAnnotationProperties(vfb_ind)
ont_dict = {}
ont_dict['vfb_ind']=vfb_ind
ont_dict['fbbt'] = load_ont(FBBT)
#ont_dict['fbbt'] = load_ont("http://purl.obolibrary.org/obo/fbbt/%s/fbbt-simple.owl" % fbbt_release_version)
ont_dict['fb_feature'] = load_ont("../../owl/fb_features.owl")
#ont_dict['fb_feature'] = load_ont("http://purl.obolibrary.org/obo/fbbt/vfb/fb_features.owl")
# Now run all the functions
gen_ind_by_source(nc, ont_dict, dataset)
gen_ind_by_source(nc, ont_dict, "CostaJefferis_v3") # Add v3 clusters
#add_manual_ann(conn.cursor(), vfb_ind)
add_BN_dom_overlap(nc, vfb_ind, ont_dict['fbbt'])
map_to_clusters(nc, vfb_ind)
# Save output file and clean up
vfb_ind.save("../../owl/flycircuit_plus.owl")
#conn.close()
vfb_ind.sleep()
ont_dict['fbbt'].sleep()
ont_dict['fb_feature'].sleep()
class test_suite():
# Tests to add: add_owl_entity_2_db
def __init__(self, usr,pwd, ont_uri_list):
self.conn = get_con(usr,pwd)
self.ont = Brain()
for uri in ont_uri_list:
self.ont.learn(uri)
self.od = owlDbOnt(self.conn, self.ont)
self.cleanup_list = []
def run_tests(self):
self.add_ind_type_test()
self.add_akv_type_test()
self.cleanup()
self.ont.sleep()
self.conn.close()
def add_ind_type_test(self):
"""Combined test of add ind and add_ind_type..
"""
# A better test would use silly examples that could never be real, so all entities could safely be deleted.
# add ind_test where name has quotes to be escaped.
self.od.add_ind("add_ind_test", 'CostaJefferis')
cursor = self.conn.cursor()
cursor.execute("SELECT * from owl_individual WHERE label = 'add_ind_test'")
dc = dict_cursor(cursor)
iid = False
for d in dc:
if d['label'] == "add_ind_test":
iid = d['id']
else:
warnings.warn("Failed to add test ind")
cursor.close()
# add ind_type_test
if iid:
self.od.add_ind_type(ind = iid, OWLclass = 'FBbt_00003624', objectProperty = 'BFO_0000050')
typ = self.od.type_exists('FBbt_00003624', 'BFO_0000050')
self.od.add_ind_type(ind = iid, OWLclass = 'FBgn0000490', objectProperty = 'RO_0002292')
typ2 = self.od.type_exists('FBgn0000490', 'RO_0002292')
stat = False
if not typ:
warnings.warn("Failed to create test type statement 'BFO_0000050' some 'FBbt_00003624'")
elif not typ2:
warnings.warn("Failed to create test type statement 'expresses some dpp'.")
else:
stat = True
# No longer needed as DELETE cascade set
# self.cleanup_list.append("DELETE FROM individual_type WHERE id = %s" % typ) # Type assertions must be deleted first.
# self.cleanup_list.append("DELETE FROM individual_type WHERE id = %s" % typ2) # Type assertions must be deleted first.
self.cleanup_list.append("DELETE from owl_individual WHERE label = 'add_ind_test'")
return stat
def add_akv_type_test(self):
self.od.add_akv_type('process', 'note','FBbt_00003624', 'BFO_0000050')
cursor = self.conn.cursor()
cursor.execute("SELECT at.id FROM annotation_type at " \
"JOIN annotation_key_value akv ON (akv.id = at.annotation_key_value_id) " \
"JOIN owl_type ot ON (ot.id=at.owl_type_id)")
dc = dict_cursor(cursor)
ID = ''
for d in dc:
ID = d['id']
if not ID:
warnings.warn("Failed to add akv type.")
self.cleanup_list.append("DELETE FROM annotation_type WHERE id = %s" % ID)
return ID
def cleanup(self):
cursor = self.conn.cursor()
for command in self.cleanup_list:
cursor.execute(command)
self.conn.commit()
if fb['obstat']:
warnings.warn(fb['fbid'] +" " + fb['uc_name'] + " is obsolete ! Not adding to fb_feature.owl.")
else:
if not fb_feature.knowsClass(fb['fbid']): # Only add class if not obsolete.
fb_feature.addClass(fb['fbid'])
tmp = re.sub("<up\>", "[",fb['uc_name'])
uc_name = re.sub("<\/up>", "]", tmp)
fb_feature.label(fb['fbid'], uc_name)
if re.match('FBtp\d+', fb['fbid']):
fb_feature.subClassOf(fb['fbid'], 'SO_0000796')
elif re.match('FBti\d+', fb['fbid']):
fb_feature.subClassOf(fb['fbid'], 'SO_0001218')
elif re.match('FBgn\d+', fb['fbid']):
fb_feature.subClassOf(fb['fbid'], 'SO_0000704')
elif re.match('FBal\d+', fb['fbid']):
fb_feature.subClassOf(fb['fbid'], 'SO_0001023')
else:
warnings.warn("Ignoring this, as doesn't look like an FB feature: %s." % fb['fbid'])
continue
time.sleep(0.1)
# vfb_ms_conn.close()
fb_cursor.close()
fb_pg_conn.close()
fb_feature.save("../../owl/fb_features.owl") # yuk
fb_feature.sleep()
#!/usr/bin/env jython
from uk.ac.ebi.brain.core import Brain
import json
gorel = Brain()
gorel.learn("http://purl.obolibrary.org/obo/go/extensions/gorel.owl")
# Declaring AE rels as list for now.
relations = [ "GOREL_0001006" ]
# Would be better to pull list of AE rels automatically from file.
#With current structure, thus would require pulling subproperties. Can't do that with Brain.
# Iterate over list, pulling usage and saving to file named for relation:
for r in relations:
label = gorel.getLabel(r)
usage = gorel.getAnnotation(r, "usage")
usage_md = open("../.gitdown/" + label + "_usage.md", "w")
usage_md.write(usage)
usage_md.close()
gorel.sleep()
# Using related link. Can denormalise with generic edge naming script.
s = "MATCH (I:Individual), (C:Class) WHERE I.short_form = '%s'" \
"AND C.short_form = '%s' MERGE (I)-[r:Related {label: '%s', short_form: '%s' }]->(C)" \
% (i, t['objectId'], rel, t['relId']) #
statements.append(s)
facts = vom.get_triples(sfid = i)
for f in facts:
rel = re.sub(' ', '_', vfb.getLabel(f[1]))
s = "MATCH (I1:Individual), (I2:Individual) " \
"WHERE I1.short_form = '%s' and I2.short_form = '%s' " \
"MERGE (I1)-[r:Related { label: '%s', short_form: '%s' }]-(I2)" \
% (f[0], f[2], rel, f[1])
statements.append(s)
nc.commit_list_in_chunks(statements, verbose = True, chunk_length = 1000)
vfb.sleep()
# Inds from graph (probably don't need this)
# payload = {'statements': [{'statement': 'MATCH (i:Individual) RETURN i.short_form'}]}
# ind_q_res = requests.post(url = "%s/db/data/transaction/commit" % base_uri, auth = (usr, pwd) , data = json.dumps(payload))
# rj= rels.json()
# inds = rj['results'][0]['data']
