def do_insert(config="default.conf", logging=False): if config: if isinstance(config, P.Configure): pass elif isinstance(config, str): config = P.Configure.open(config) elif isinstance(config, dict): config = P.Configure().copy(config) else: raise Exception("Invalid configuration object "+ str(config)) P.connect(conf=config, do_logging=logging) try: w = P.Worm() net = P.Network() w.neuron_network(net) w.save() upload_neurons() upload_muscles() upload_lineage_and_descriptions() upload_synapses() upload_receptors_and_innexins() upload_types() serialize_as_n3() #infer() except: traceback.print_exc() finally: P.disconnect()
def setUp(self): PyOpenWorm.connect(conf=Configure( **{ 'rdf.store_conf': 'tests/test.db', 'rdf.source': 'ZODB' })) self.g = PyOpenWorm.config("rdf.graph")
def __init__(self, cw_obj): # initialize PyOpenWorm connection so we can access its API P.connect() self.channelworm_object = cw_obj cw_dict = model_to_dict(self.channelworm_object) experiment_id = cw_dict.pop('experiment') patch_clamp_id = cw_dict.pop('id') self.pyopenworm_object = P.Experiment() # get the CW model's experiment cw_evidence = C.Experiment.objects.get(id=experiment_id) # make a PyOW evidence object with it pow_evidence = P.Evidence(doi=cw_evidence.doi) # add it to the PyOW experiment model self.pyopenworm_object.reference(pow_evidence) for key, value in cw_dict.iteritems(): self.pyopenworm_object.conditions.set(key, value) # we not longer need PyOW API so we can kill the connection P.disconnect()
def Evidences(request): P.connect() try: EVIDENCE_DICT = {} count = 0 for evidence in P.Evidence().load(): EVIDENCE_DICT[str(count)] = { 'index': count, 'doi': list(evidence.doi.get()), 'pmid': list(evidence.pmid.get()), 'wormbaseid': list(evidence.wbid.get()), 'author': list(evidence.author.get()), 'title': list(evidence.title.get()), 'year': list(evidence.year.get()), 'uri': list(evidence.uri.get()), 'completeness': '#2B7558' } count += 1 finally: P.disconnect() return render_to_response('pyopenworm/evidences.html', {'evidences': EVIDENCE_DICT})
def __init__(self, cw_obj): self.channelworm_object = cw_obj self.map_properties() P.connect() self.pyopenworm_object.set_data(cw_obj.asarray()) P.disconnect()
def do_insert(config="default.conf", logging=False): if config: if isinstance(config, P.Configure): pass elif isinstance(config, str): config = P.Configure.open(config) elif isinstance(config, dict): config = P.Configure().copy(config) else: raise Exception("Invalid configuration object " + str(config)) P.connect(conf=config, do_logging=logging) try: w = P.Worm() net = P.Network() w.neuron_network(net) w.save() upload_neurons() upload_muscles() upload_lineage_and_descriptions() upload_synapses() upload_receptors_and_innexins() upload_types() serialize_as_n3() #infer() except: traceback.print_exc() finally: P.disconnect()
def __init__(self, cw_obj): # initialize PyOpenWorm connection so we can access its API P.connect() self.channelworm_object = cw_obj cw_dict = model_to_dict(self.channelworm_object) experiment_id = cw_dict.pop('experiment') patch_clamp_id = cw_dict.pop('id') self.pyopenworm_object = P.Experiment() # get the CW model's experiment cw_evidence = C.Experiment.objects.get(id=experiment_id) # make a PyOW evidence object with it pow_evidence = P.Evidence(doi=cw_evidence.doi) # add it to the PyOW experiment model self.pyopenworm_object.reference(pow_evidence) for key, value in cw_dict.iteritems(): self.pyopenworm_object.conditions.set(key, value) # we not longer need PyOW API so we can kill the connection P.disconnect()
def __init__(self, cw_obj): self.channelworm_object = cw_obj self.map_properties() P.connect() # mapping evidence to Assertions pmids = cw_obj.expression_evidences.split(', ') for pmid in pmids: e = P.Evidence() e.pmid(pmid) e.asserts(self.pyopenworm_object.expression_pattern) e.save() pmids = cw_obj.description_evidences.split(', ') for pmid in pmids: e = P.Evidence() e.pmid(pmid) e.asserts(self.pyopenworm_object.description) e.save() # proteins in CW are ;-delimited, but should be #multiple values in PyOpenWorm pros = cw_obj.proteins.split('; ') for p in pros: self.pyopenworm_object.proteins(p)
def test_adapt_reference(data_pool): """Test that we can map a Reference object to a PyOpenWorm Experiment object.""" r = data_pool.get_reference() reference_adapter = Adapter.create(r) experiment = reference_adapter.get_pow() reference = reference_adapter.get_cw() PyOpenWorm.connect() pyow_dict = { 'authors': experiment.author(), 'doi': experiment.doi(), 'pmid': experiment.pmid(), 'title': experiment.title(), 'url': experiment.uri(), 'year': experiment.year(), } cw_dict = { 'authors': set([reference.authors]), 'doi': reference.doi, 'pmid': reference.PMID, 'title': reference.title, 'url': set([reference.url]), 'year': reference.year } PyOpenWorm.disconnect() assert pyow_dict == cw_dict
def setUpClass(cls): import csv cls.neurons = [ ] #array that holds the names of the 302 neurons at class-level scope if not USE_BINARY_DB: PyOpenWorm.connect(conf=Data( )) # Connect for integrity tests that use PyOpenWorm functions cls.g = PyOpenWorm.config( 'rdf.graph') # declare class-level scope for the database cls.g.parse("OpenWormData/WormData.n3", format="n3") # load in the database else: conf = Configure(**{ "rdf.source": "ZODB", "rdf.store_conf": BINARY_DB }) PyOpenWorm.connect(conf=conf) cls.g = PyOpenWorm.config('rdf.graph') #grab the list of the names of the 302 neurons csvfile = open('OpenWormData/aux_data/neurons.csv', 'r') reader = csv.reader(csvfile, delimiter=';', quotechar='|') for row in reader: if len(row[0]) > 0: # Only saves valid neuron names cls.neurons.append(row[0])
def __init__(self): logger.info("Initialising OpenWormReader") P.connect() self.net = P.Worm().get_neuron_network() self.all_connections = self.net.synapses() self.neuron_connections = set(filter(lambda x: x.termination() == u'neuron', self.all_connections)) self.muscle_connections = set(filter(lambda x: x.termination() == u'muscle', self.all_connections)) logger.info("Finished initialising OpenWormReader")
def __enter__(self): # if P.connected: # raise RuntimeError("Already connected") P.connect(POW_CONF_PATH) self.ctx = Context(ident=WORM_IDENT) self.worm = self.ctx.stored(Worm)() self.net = self.worm.neuron_network() return self
def setUp(self): # Set do_logging to True if you like walls of text self.TestConfig = Configure.open(TEST_CONFIG) td = '__tempdir__' z = self.TestConfig['rdf.store_conf'] if z.startswith(td): x = z[len(td):] h=tempfile.mkdtemp() self.TestConfig['rdf.store_conf'] = h + x self.delete_dir() PyOpenWorm.connect(conf=self.TestConfig, do_logging=False)
def setUp(self): # Set do_logging to True if you like walls of text self.TestConfig = Configure.open(TEST_CONFIG) td = '__tempdir__' z = self.TestConfig['rdf.store_conf'] if z.startswith(td): x = z[len(td):] h = tempfile.mkdtemp() self.TestConfig['rdf.store_conf'] = h + x self.delete_dir() PyOpenWorm.connect(conf=self.TestConfig, do_logging=False)
def _get_cell_info(cells): import PyOpenWorm as P print("Connecting to the PyOpenWorm database...") P.connect() #Get the worm object. worm = P.Worm() #Extract the network object from the worm object. net = worm.neuron_network() #Go through our list and get the neuron object associated with each name. #Store these in another list. some_neurons = [P.Neuron(name) for name in cells] all_neuron_info = collections.OrderedDict() all_muscle_info = collections.OrderedDict() for neuron in some_neurons: print("=====Checking properties of: %s"%neuron) print neuron.triples() print neuron.__class__ short = ') %s'%neuron.name() if 'motor' in neuron.type(): short = 'Mo%s'%short if 'sensory' in neuron.type(): short = 'Se%s'%short if 'interneuron' in neuron.type(): short = 'In%s'%short if _is_muscle(neuron.name()): short = 'Mu%s'%short short = '(%s'%short if 'GABA' in neuron.neurotransmitter(): short = '- %s'%short elif len(neuron.neurotransmitter())==0: short = '? %s'%short else: short = '+ %s'%short info = (neuron, neuron.type(), neuron.receptor(), neuron.neurotransmitter(), short) #print dir(neuron) if _is_muscle(neuron.name()): all_muscle_info[neuron.name()] = info else: all_neuron_info[neuron.name()] = info return all_neuron_info, all_muscle_info
def handle(self, *args, **options): P.connect() print 'clearing data' self.Del_Neuron() self.Del_Muscle() self.Del_IonChannel() print 'done' print "calculating scores" self.scoring_ionchannels() self.scoring_neurons() self.scoring_muscles() P.disconnect() print "scores calculated"
def Channels(request): P.connect() try: CHANNEL_DICT = {} for channel in P.Channel().load(): CHANNEL_DICT[str(channel)] = { 'name': str(channel), 'completeness': '#2B7558' } finally: P.disconnect() return render_to_response('pyopenworm/channels.html', {'channels': CHANNEL_DICT})
def Muscles(request): P.connect() try: MUSCLE_DICT = {} for muscle in P.Muscle().load(): MUSCLE_DICT[str(muscle)] = { 'name': str(muscle), 'completeness': '#2B7558' } finally: P.disconnect() return render_to_response('pyopenworm/muscles.html', {'muscles': MUSCLE_DICT})
def Neurons(request): P.connect() try: NEURON_DICT = {} for neuron in P.Neuron().load(): NEURON_DICT[str(neuron)] = { 'name': str(neuron), 'completeness': '#2B7558' } finally: P.disconnect() return render_to_response('pyopenworm/neurons.html', {'neurons': NEURON_DICT})
def Channel(request, channel_id): P.connect() try: channel_dict = {} for channel in P.Channel().load(): channel_dict[str(channel)] = { 'name': str(channel), 'completeness': '#2B7558' } finally: P.disconnect() return render_to_response('pyopenworm/channel.html', {'channel': channel_dict[channel_id]})
def setUp(self): xfail_without_db() self.conn = PyOpenWorm.connect( configFile='tests/data_integrity_test.conf') self.g = self.conn.conf["rdf.graph"] self.context = Context() self.qctx = self.context.stored
def test_adapt_GraphData(data_pool): """ Test that we can map some GraphData to a PyOpenWorm data object. """ graph_data = data_pool.get_graph_data() gda = Adapter.create(graph_data) cw_obj = gda.get_cw() pow_obj = gda.get_pow() PyOpenWorm.connect() assert cw_obj.asarray() == pow_obj.data PyOpenWorm.disconnect()
def setUp(self): self.conn = PyOpenWorm.connect( configFile='tests/data_integrity_test.conf') self.conf = self.conn.conf self.g = self.conf["rdf.graph"] self.context = Context(ident="http://openworm.org/data", conf=self.conf) self.qctx = self.context.stored
def map_properties(self): """ Map between the properties defined in the subclass. """ # initialize PyOpenWorm connection so we can access its API P.connect() # initialize pyopenworm object self.pyopenworm_object = self.pyopenworm_class() for p, c in self.pyow_to_cw.items(): cw_value = getattr(self.channelworm_object, c) pow_property = getattr(self.pyopenworm_object, p) map(pow_property, [cw_value]) P.disconnect()
def setUpClass(cls): import csv PyOpenWorm.connect( conf=Configure( **{'rdf.store_conf': 'tests/test.db', 'rdf.source': 'ZODB'})) PyOpenWorm.loadData(skipIfNewer=False) PyOpenWorm.disconnect() # grab the list of the names of the 302 neurons csvfile = open('OpenWormData/aux_data/neurons.csv', 'r') reader = csv.reader(csvfile, delimiter=';', quotechar='|') # array that holds the names of the 302 neurons at class-level scope cls.neurons = [] for row in reader: if len(row[0]) > 0: # Only saves valid neuron names cls.neurons.append(row[0])
def setUpClass(cls): import csv PyOpenWorm.connect(conf=Configure( **{ 'rdf.store_conf': 'tests/test.db', 'rdf.source': 'ZODB' })) PyOpenWorm.loadData(skipIfNewer=False) PyOpenWorm.disconnect() # grab the list of the names of the 302 neurons csvfile = open('OpenWormData/aux_data/neurons.csv', 'r') reader = csv.reader(csvfile, delimiter=';', quotechar='|') # array that holds the names of the 302 neurons at class-level scope cls.neurons = [] for row in reader: if len(row[0]) > 0: # Only saves valid neuron names cls.neurons.append(row[0])
def Muscle(request, muscle_id): P.connect() try: muscle_dict = {} for muscle in P.Muscle(muscle_id).load(): ''' 'neurons': list(muscle.neurons.get()), 'receptors': list(muscle.receptors.get()), ''' muscle_dict[str(muscle)] = { 'name': str(muscle), 'completeness': '#2B7558' } finally: P.disconnect() return render_to_response('pyopenworm/muscle.html', {'muscle': muscle_dict[muscle_id]})
def do_insert(config="default.conf", logging=False): global SQLITE_EVIDENCE global WORM global NETWORK if config: if isinstance(config, P.Configure): pass elif isinstance(config, str): config = P.Configure.open(config) elif isinstance(config, dict): config = P.Configure().copy(config) else: raise Exception("Invalid configuration object " + str(config)) P.connect(conf=config, do_logging=logging) SQLITE_EVIDENCE = P.Evidence(key="C_elegans_SQLite_DB", title="C. elegans sqlite database") try: WORM = P.Worm() NETWORK = P.Network() WORM.neuron_network(NETWORK) NETWORK.worm(WORM) upload_neurons() upload_muscles() upload_lineage_and_descriptions() upload_connections() upload_receptors_types_neurotransmitters_neuropeptides_innexins() upload_additional_receptors_neurotransmitters_neuropeptides_innexins() print("Saving...") WORM.save() #infer() print("Serializing...") serialize_as_n3() except Exception: traceback.print_exc() finally: P.disconnect()
def Neuron(request, neuron_id): P.connect() try: neuron_dict = {} for neuron in P.Neuron(neuron_id).load(): neuron_dict[str(neuron)] = { 'name': str(neuron), 'type': list(neuron.type.get()), 'receptor': list(neuron.receptor.get()), 'innexin': list(neuron.innexin.get()), 'neurotransmitter': list(neuron.neurotransmitter.get()), 'neuropeptide': list(neuron.neuropeptide.get()), 'completeness': '#2B7558' } finally: P.disconnect() return render_to_response('pyopenworm/neuron.html', {'neuron': neuron_dict[neuron_id]})
def setUp(self): # Set do_logging to True if you like walls of text self.TestConfig = Data.open(TEST_CONFIG) td = '__tempdir__' z = self.TestConfig['rdf.store_conf'] if z.startswith(td): x = z[len(td):] h = tempfile.mkdtemp() self.TestConfig['rdf.store_conf'] = h + x self.delete_dir() PyOpenWorm.connect(conf=self.TestConfig, do_logging=False) self.context = Context(ident='http://example.org/test-context', conf=self.TestConfig) typ = type(self) if hasattr(typ, 'ctx_classes'): if isinstance(dict, typ.ctx_classes): self.ctx = self.context(typ.ctx_classes) else: self.ctx = self.context( {x.__name__: x for x in typ.ctx_classes})
def do_insert(config="default.conf", logging=False): global SQLITE_EVIDENCE global WORM global NETWORK if config: if isinstance(config, P.Configure): pass elif isinstance(config, str): config = P.Configure.open(config) elif isinstance(config, dict): config = P.Configure().copy(config) else: raise Exception("Invalid configuration object " + str(config)) P.connect(conf=config, do_logging=logging) SQLITE_EVIDENCE = P.Evidence(key="C_elegans_SQLite_DB", title="C. elegans sqlite database") try: WORM = P.Worm() NETWORK = P.Network() WORM.neuron_network(NETWORK) NETWORK.worm(WORM) upload_neurons() upload_muscles() upload_lineage_and_descriptions() upload_connections() upload_receptors_types_neurotransmitters_neuropeptides_innexins() print("Saving...") WORM.save() infer() print("Serializing...") serialize_as_n3() except: traceback.print_exc() finally: P.disconnect()
def read_data(include_nonconnected_cells=False): print_("Initialising OpenWormReader") P.connect() net = P.Worm().get_neuron_network() all_connections = net.synapses() print_("Finished initialising OpenWormReader") conns = [] cells = [] cell_names = get_cells_in_model(net) for s in all_connections: pre = str(s.pre_cell().name()) post = str(s.post_cell().name()) if isinstance(s.post_cell(), P.Neuron) and pre in cell_names and post in cell_names: syntype = str(s.syntype()) syntype = syntype[0].upper() + syntype[1:] num = int(s.number()) synclass = str(s.synclass()) ci = ConnectionInfo(pre, post, num, syntype, synclass) conns.append(ci) if pre not in cells: cells.append(pre) if post not in cells: cells.append(post) print_("Total cells %i (%i with connections)" % (len(cell_names), len(cells))) print_("Total connections found %i " % len(conns)) P.disconnect() if include_nonconnected_cells: return cell_names, conns else: return cells, conns
def setUpClass(cls): import csv cls.neurons = [] #array that holds the names of the 302 neurons at class-level scope if not USE_BINARY_DB: PyOpenWorm.connect(conf=Data()) # Connect for integrity tests that use PyOpenWorm functions cls.g = PyOpenWorm.config('rdf.graph') # declare class-level scope for the database cls.g.parse("OpenWormData/WormData.n3", format="n3") # load in the database else: conf = Configure(**{ "rdf.source" : "ZODB", "rdf.store_conf" : BINARY_DB }) PyOpenWorm.connect(conf=conf) cls.g = PyOpenWorm.config('rdf.graph') #grab the list of the names of the 302 neurons csvfile = open('OpenWormData/aux_data/neurons.csv', 'r') reader = csv.reader(csvfile, delimiter=';', quotechar='|') for row in reader: if len(row[0]) > 0: # Only saves valid neuron names cls.neurons.append(row[0])
def test_adapt_PatchClamp(data_pool): """ Test that we can map a PatchClamp object to a PyOpenWorm PatchClamp object. """ pc = data_pool.get_patch_clamp() pca = Adapter.create(pc) cw_obj = pca.get_cw() pow_obj = pca.get_pow() PyOpenWorm.connect() pow_dict = { 'delta_t': pow_obj.delta_t(), 'duration': pow_obj.duration(), 'end_time': pow_obj.end_time(), 'ion_channel': pow_obj.ion_channel(), 'protocol_end': pow_obj.protocol_end(), 'protocol_start': pow_obj.protocol_start(), 'protocol_step': pow_obj.protocol_step(), 'start_time': pow_obj.start_time(), } cw_dict = { 'delta_t': cw_obj.deltat, 'duration': cw_obj.duration, 'end_time': cw_obj.end_time, 'ion_channel': cw_obj.ion_channel, 'protocol_end': cw_obj.protocol_end, 'protocol_start': cw_obj.protocol_start, 'protocol_step': cw_obj.protocol_step, 'start_time': cw_obj.start_time, } PyOpenWorm.disconnect() assert cw_dict == pow_dict
def do_insert(): import sys logging = False if len(sys.argv) > 1 and sys.argv[1] == '-l': logging = True P.connect(configFile='default.conf', do_logging=logging) try: upload_neurons() print ("uploaded neurons") #upload_muscles() print ("uploaded muscles") upload_lineage_and_descriptions() print ("uploaded lineage and descriptions") #upload_synapses() print ("uploaded synapses") #upload_receptors_and_innexins() print ("uploaded receptors and innexins") #infer() print ("filled in with inferred data") except: traceback.print_exc() finally: P.disconnect()
def do_insert(): import sys logging = False if len(sys.argv) > 1 and sys.argv[1] == '-l': logging = True P.connect(configFile='default.conf', do_logging=logging) try: upload_muscles() print ("uploaded muscles") upload_lineage_and_descriptions() print ("uploaded lineage and descriptions") upload_synapses() print ("uploaded synapses") upload_receptors_and_innexins() print ("uploaded receptors and innexins") update_neurons_and_muscles_with_lineage_and_descriptions() print ("updated muscles and neurons with cell data") infer() print ("filled in with inferred data") except: traceback.print_exc() finally: P.disconnect()
def setUp(self): # Set do_logging to True if you like walls of text self.TestConfig = Data.open(TEST_CONFIG) td = '__tempdir__' z = self.TestConfig['rdf.store_conf'] if z.startswith(td): x = z[len(td):] h = tempfile.mkdtemp() self.TestConfig['rdf.store_conf'] = h + x self.delete_dir() self.connection = PyOpenWorm.connect(conf=self.TestConfig, do_logging=False) self.context = Context(ident='http://example.org/test-context', conf=self.TestConfig) typ = type(self) if hasattr(typ, 'ctx_classes'): if isinstance(dict, typ.ctx_classes): self.ctx = self.context(typ.ctx_classes) else: self.ctx = self.context({x.__name__: x for x in typ.ctx_classes})
Try running this script and see what it prints out. It takes a while to run because there are so many connections, so feel free to comment out some of the neuron names in the arbitrary list declared further below. """ from __future__ import absolute_import from __future__ import print_function import PyOpenWorm as P from PyOpenWorm.worm import Worm from PyOpenWorm.neuron import Neuron from PyOpenWorm.context import Context from OpenWormData import BIO_ENT_NS print("Connecting to the database...") conn = P.connect('default.conf') ctx = Context(ident=BIO_ENT_NS['worm0'], conf=conn.conf).stored #Get the worm object. worm = ctx(Worm)() #Extract the network object from the worm object. net = worm.neuron_network() #Make a list of some arbitrary neuron names. some_neuron_names = ["ADAL", "AIBL", "I1R", "PVCR", "DD5"] #Go through our list and get the neuron object associated with each name. #Store these in another list. some_neurons = [ctx(Neuron)(name) for name in some_neuron_names]
""" How to get a particular Neuron's gap junctions from the database. """ import PyOpenWorm as P #Connect to existing database. P.connect() #Put the Worm's Network object in a variable. net = P.Worm().get_neuron_network() #Put a particular Neuron object in a variable ('AVAL' in this example). aval = net.aneuron('AVAL') print("Getting all Connections to/from AVAL, and printing the gap junctions") #We could also put them into an array or do other things with them other than print. num_gjs = 0 for c in aval.connection(): #the `one()` returns a string like "gapJunction" instead of "syntype=gapJunction" if c.syntype.one() == 'gapJunction': num_gjs += 1 print num_gjs, c
def setUp(self): PyOpenWorm.connect(configFile='tests/data_integrity_test.conf') self.g = PyOpenWorm.config("rdf.graph") self.context = Context() self.qctx = self.context.stored
""" from __future__ import absolute_import from __future__ import print_function import PyOpenWorm as P from PyOpenWorm.evidence import Evidence from PyOpenWorm.neuron import Neuron from PyOpenWorm.document import Document from PyOpenWorm.data import Data from PyOpenWorm.context import Context # Create dummy database configuration. d = Data() # Connect to database with dummy configuration conn = P.connect(conf=d) ctx = Context(ident='http://example.org/data', conf=conn.conf) evctx = Context(ident='http://example.org/meta', conf=conn.conf) # Create a new Neuron object to work with n = ctx(Neuron)(name='AVAL') # Create a new Evidence object with `doi` and `pmid` fields populated. # See `PyOpenWorm/evidence.py` for other available fields. d = evctx(Document)(key='Anonymous2011', doi='125.41.3/ploscompbiol', pmid='12345678') e = evctx(Evidence)(key='Anonymous2011', reference=d) # Evidence object asserts something about the enclosed dataObject. # Here we add a receptor to the Neuron we made earlier, and "assert it". # As the discussion (see top) reads, this might be asserting the existence of
def setUpClass(self): PyOpenWorm.connect() PyOpenWorm.loadData(skipIfNewer=False) PyOpenWorm.disconnect() os.chdir('examples')
def setUp(self): PyOpenWorm.connect( conf=Configure( **{'rdf.store_conf': 'tests/test.db', 'rdf.source': 'ZODB'})) self.g = PyOpenWorm.config("rdf.graph")
def fetch_ma_mapping(): """Fetch associations between monoamines and their receptors from Bentley data. :return: dict from full monoamine names (title case) to cognate receptor gene names (upper case). """ url = BASE_URL + "monoamine_receptor_expression.tsv" mapping = defaultdict(set) for row in csv.DictReader(decode_lines(urlopen(url)), delimiter='\t'): if int(row.get("excluded", 0)): continue mapping[row["monoamine"].title()].add(row["receptor"].upper()) return mapping with P.connect('default.conf') as conn: ctx = Context(ident=BIO_ENT_NS['worm0'], conf=conn.conf).stored #Get the worm object. worm = ctx(Worm)() #Extract the network object from the worm object. net = worm.neuron_network() cell_transmitter_mapping, receptor_cell_mapping = get_mappings() ma_t_r_mapping = fetch_ma_mapping() ma_edges = list(get_possible_extrasynaptic_edges(cell_transmitter_mapping, ma_t_r_mapping, receptor_cell_mapping)) np_t_r_mapping = fetch_np_mapping() np_edges = list(get_possible_extrasynaptic_edges(cell_transmitter_mapping, np_t_r_mapping, receptor_cell_mapping)) print('Monamine edges: count={}'.format(len(ma_edges)))
def setUp(self): xfail_without_db() self.conn = PyOpenWorm.connect(configFile='tests/data_integrity_test.conf') self.g = self.conn.conf["rdf.graph"] self.context = Context() self.qctx = self.context.stored
def __init__(self): P.connect() self.net = P.Worm().get_neuron_network() self.all_connections = self.net.synapses()
def setUp(self): PyOpenWorm.connect(configFile='tests/data_integrity_test.conf') self.g = PyOpenWorm.config("rdf.graph") self.context = Context() self.qctx = self.context.stored
import PyOpenWorm as P import rdflib as R import unittest import os P.connect("default.conf") #create new muscle object m = P.Muscle() #save muscle to graph (and infer new triples to it, based on rules) m.save() #get the graph associated with th muscle cell graph = m.rdf.serialize(format="n3") P.disconnect() #remove unnecessary files from directory os.remove("worm.db") os.remove("worm.db.tmp") os.remove("worm.db.lock") os.remove("worm.db.index") class InferenceTest(unittest.TestCase): def testIfInferred(self): #this will fail unless "TestClass" is in the graph self.failUnless("<http://openworm.org/entities/TestClass>" in graph) def main():
def __init__(self): logger.info("Initialising OpenWormReader") P.connect() self.net = P.Worm().get_neuron_network() self.all_connections = self.net.synapses() logger.info("Finished initialising OpenWormReader")
import PyOpenWorm from time import time from PyOpenWorm.neuron import Neuron PyOpenWorm.connect(configFile='PyOpenWorm/default.conf') t0 = time() print("Neurons:") print(", ".join(sorted(Neuron().name.get()))) print("Receptors:") print(", ".join(sorted(Neuron().receptor.get()))) tot = time() - t0 print ("Took {} seconds".format(tot))
def do_insert(ident, config="default.conf", logging=False, imports_context_ident=None, basedir=aux_data()): sources = init_sources() extras = init_extra_sources(basedir) data_sources_by_key = {x.key: x for x in sources + extras} trans_map = init_translators() + init_extra_neuron_data_translators(extras) P.connect(configFile=config, do_logging=logging) P.config() CTX = Context(ident=ident + '-data', imported=(P.CONTEXT,), conf=P.config()) EVCTX = Context(ident=ident + '-evidence', imported=(P.CONTEXT,), conf=P.config()) IWCTX = Context(ident=ident, imported=(CTX, EVCTX), conf=P.config()) imports_context = Context(ident=imports_context_ident, conf=P.config()) try: t0 = time() translators = dict() remaining = list(trans_map) last_remaining = None saved_contexts = set([]) while remaining != last_remaining: next_remaining = [] for t in remaining: if not isinstance(t[0], (list, tuple)): source_keys = (t[0],) else: source_keys = t[0] sources = tuple(data_sources_by_key.get(s) for s in source_keys) if None in sources: next_remaining.append(t) continue translator_class = t[1] if len(t) > 2: output_key = t[2] else: output_key = None translator = translators.get(translator_class, None) if not translator: translator = translator_class() translators[translator_class] = translator print('\n'.join('Input({}/{}): {}'.format(i + 1, len(sources), s) for i, s in enumerate(sources))) print('Translating with {}'.format(translator)) orig_wd = os.getcwd() os.chdir(basedir) try: res = translator(*sources, output_key=output_key) finally: os.chdir(orig_wd) print('Result: {}'.format(res)) if isinstance(res, DataWithEvidenceDataSource): res.data_context.save_context(inline_imports=True, saved_contexts=saved_contexts) res.data_context.save_imports(imports_context) res.evidence_context.save_context(inline_imports=True, saved_contexts=saved_contexts) res.evidence_context.save_imports(imports_context) for ctx in res.contexts: raise Exception() if res: if res.key: data_sources_by_key[res.key] = res else: data_sources_by_key[res.identifier] = res last_remaining = list(remaining) remaining = next_remaining for x in remaining: warn("Failed to process: {}".format(x)) # attach_neuromlfiles_to_channel() t1 = time() print("Saving data...") graph = P.config('rdf.graph') for src in data_sources_by_key.values(): if isinstance(src, DataWithEvidenceDataSource): print('saving', src) CTX.add_import(src.data_context) EVCTX.add_import(src.evidence_context) for ctx in src.contexts: IWCTX.add_import(ctx) IWCTX.save_context(graph, saved_contexts=saved_contexts) IWCTX.save_imports(imports_context) print('imports context size', len(imports_context)) print("Saved %d triples." % IWCTX.triples_saved) t2 = time() print("Serializing...") serialize_as_nquads() t3 = time() print("generating objects took", t1 - t0, "seconds") print("saving objects took", t2 - t1, "seconds") print("serializing objects took", t3 - t2, "seconds") except Exception: traceback.print_exc() finally: P.disconnect()
""" from __future__ import absolute_import from __future__ import print_function import PyOpenWorm as P from PyOpenWorm.evidence import Evidence from PyOpenWorm.neuron import Neuron from PyOpenWorm.document import Document from PyOpenWorm.data import Data from PyOpenWorm.context import Context # Create dummy database configuration. d = Data({'rdf.source': 'ZODB'}) # Connect to database with dummy configuration P.connect(conf=d) ctx = Context(ident='http://example.org/data') evctx = Context(ident='http://example.org/meta') # Create a new Neuron object to work with n = ctx(Neuron)(name='AVAL') # Create a new Evidence object with `doi` and `pmid` fields populated. # See `PyOpenWorm/evidence.py` for other available fields. d = evctx(Document)(key='Anonymous2011', doi='125.41.3/ploscompbiol', pmid='12345678') e = evctx(Evidence)(key='Anonymous2011', reference=d) # Evidence object asserts something about the enclosed dataObject. # Here we add a receptor to the Neuron we made earlier, and "assert it". # As the discussion (see top) reads, this might be asserting the existence of
def setUp(self): self.conn = PyOpenWorm.connect(configFile='tests/data_integrity_test.conf') self.conf = self.conn.conf self.g = self.conf["rdf.graph"] self.context = Context(ident="http://openworm.org/data", conf=self.conf) self.qctx = self.context.stored