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 serialize_as_n3(): dest = '../WormData.n3' # XXX: Properties aren't initialized until the first object of a class is created, # so we create them here P.config('rdf.graph').serialize(dest, format='n3') print('serialized to n3 file')
def serialize_as_n3(): dest = "../WormData.n3" # XXX: Properties aren't initialized until the first object of a class is created, # so we create them here P.config("rdf.graph").serialize(dest, format="n3") print("serialized to n3 file")
def read(self): conns = [] cells = [] cell_names = owr.get_cells_in_model() for s in self.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) logger.info("Total cells read " + str(len(cells))) logger.info("Total connections read " + str(len(conns))) P.disconnect() return cells, conns
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 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): self.channelworm_object = cw_obj self.map_properties() P.connect() self.pyopenworm_object.set_data(cw_obj.asarray()) 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 __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 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 serialize_as_n3(): dest = '../WormData.n3' # XXX: Properties aren't initialized until the first object of a class is created, # so we create them here for x in dir(P): if isinstance(getattr(P, x), type) and issubclass(getattr(P, x), P.DataObject): c = getattr(P, x) if x == 'values': c("dummy") else: c() P.config('rdf.graph').serialize(dest, format='n3') print('serialized to n3 file')
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 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 read(self): conns = [] cells = [] for s in self.all_connections: pre = str(s.pre_cell()) post = str(s.post_cell()) syntype = str(s.syntype()) num = int(s.number()) synclass = str(s.synclass()) conns.append(ConnectionInfo(pre, post, num, syntype, synclass)) if pre not in cells: cells.append(pre) if post not in cells: cells.append(post) logger.info("Total cells read " + str(len(cells))) logger.info("Total connections read " + str(len(conns))) P.disconnect() return cells, conns
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 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_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})
def get(self, **kwargs): """Get a list of neighboring neurons. Parameters ---------- See parameters for PyOpenWorm.connection.Connection Returns ------- list of Neuron """ if len(self._conns) > 0: for c in self._conns: for post in c.post_cell.get(): yield post else: c = P.Connection(pre_cell=self.owner, **kwargs) for r in c.load(): yield r.post_cell()
def add_synapse(source, target): c = P.Connection(pre_cell=source, post_cell=target, number=weight, syntype=syn_type) n.synapse(c) e.asserts(c) if isinstance(source, P.Neuron) and isinstance( target, P.Neuron): c.termination('neuron') elif isinstance(source, P.Neuron) and isinstance( target, P.Muscle): c.termination('muscle') elif isinstance(source, P.Muscle) and isinstance( target, P.Neuron): c.termination('muscle') return c
def test_verify_neurons_have_evidence(self): """ For each neuron in PyOpenWorm, verify that there is supporting evidence""" neurons = list(P.Neuron().load()) evcheck = [] for n in neurons: hasEvidence = len(get_supporting_evidence(n)) + len( get_supporting_evidence(n.neurotransmitter)) + len( get_supporting_evidence(n.type)) + len( get_supporting_evidence(n.innexin)) + len( get_supporting_evidence(n.neuropeptide)) + len( get_supporting_evidence(n.receptor)) print get_supporting_evidence(n.neurotransmitter) evcheck.append(hasEvidence) self.assertTrue(0 not in evcheck, "There appears to be no evidence: " + str(evcheck))
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})
def aneuron(self, name): """ Get a neuron by name. Example:: # Grabs the representation of the neuronal network >>> net = P.Worm().get_neuron_network() # Grab a specific neuron >>> aval = net.aneuron('AVAL') >>> aval.type() set([u'interneuron']) :param name: Name of a c. elegans neuron :returns: Neuron corresponding to the name given :rtype: PyOpenWorm.Neuron """ n = P.Neuron(name=name,conf=self.conf) return n
def update_neurons_and_muscles_with_lineage_and_descriptions(): v = P.values('neurons and muscles') #XXX: This could be expensive...the lineage name and description should be loaded with # the cell though. cells = {next(x.name()) : (norn(x.lineageName()), norn(x.description())) for x in P.Cell().load() } def dtt(x): """ Do the thing """ try: name = next(x.name()) if cells[name][0] is not None: x.lineageName(cells[name][0]) if cells[name][1] is not None: x.description(cells[name][1]) v.value(x) except: traceback.print_exc() for x in P.Neuron().load(): dtt(x) for x in P.Muscle().load(): dtt(x) v.save()
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 set(self, ob, **kwargs): self.real_neighbor(ob) if isinstance(ob, NeuronClass): ob_name = ob.name() this_name = self.owner.name() for x in ob.member(): # Get the name for the neighbor # XXX: try: n = x.name() side = n[n.find(ob_name) + len(ob_name):] name_here = this_name + side this_neuron = P.Neuron(name_here) self.owner.member(this_neuron) this_neuron.neighbor(x, **kwargs) except ValueError: # XXX: could default to all-to-all semantics print 'Do not recoginze the membership of this neuron/neuron class', ob elif isinstance(ob, Neuron): for x in self.owner.member: x.neighbor(ob)
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 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_network_neurons(self): self.assertTrue('AVAL' in PyOpenWorm.Network().neurons()) self.assertTrue('DD5' in PyOpenWorm.Network().neurons()) self.assertEquals(len(PyOpenWorm.Network().neurons()), 302)
def __exit__(self, exc_type, exc_val, exc_tb): self.ctx = None self.worm = None self.net = None P.disconnect()
def upload_lineage_and_descriptions(): """ Upload lineage names and descriptions pulled from the WormAtlas master cell list Assumes that Neurons and Muscles have already been added """ # XXX: This wants a way to insert cells, then later, to insert neurons from the same set # and have the later recoginzed as the former. Identifier matching limits us here. It would # be best to establish owl:sameAs links to the super class (Cell) from the subclass (Neuron) # at the sub-class insert and have a reasoner relate # the two sets of inserts. cells = dict() try: w = P.Worm() net = w.neuron_network.one() ev = P.Evidence(uri="http://www.wormatlas.org/celllist.htm") # insert neurons. # save cell_data = open(LINEAGE_LIST_LOC, "r") # Skip headers next(cell_data) cell_name_counters = dict() data = dict() for x in cell_data: j = [x.strip().strip("\"") for x in x.split("\t")] name = j[0] lineageName = j[1] desc = j[2] # XXX: These renaming choices are arbitrary and may be inappropriate if name == "DB1/3": name = "DB1" elif name == "DB3/1": name = "DB3" elif name == "AVFL/R": if lineageName[0] == "W": name = "AVFL" elif lineageName[0] == "P": name = "AVFR" if name in cell_name_counters: while (name in cell_name_counters): cell_name_counters[name] += 1 name = name + "("+ str(cell_name_counters[name]) +")" else: cell_name_counters[name] = 0 data[name] = {"lineageName" : lineageName, "desc": desc} for n in net.neuron(): name = n.name.one() neuron_data = data[str(name)] n.lineageName(neuron_data['lineageName']) n.description(neuron_data['desc']) w.cell(n) ev.asserts(w) ev.save() except Exception, e: traceback.print_exc()
def test_muscle(self): self.assertTrue( isinstance(PyOpenWorm.Muscle('MDL08'), PyOpenWorm.Muscle))
def test_worm_get_network(self): self.assertTrue( isinstance(PyOpenWorm.Worm().get_neuron_network(), PyOpenWorm.Network))
def test_network_as_networkx(self): self.assertTrue( isinstance(PyOpenWorm.Network().as_networkx(), networkx.DiGraph))
def test_neuron_name(self): self.assertEquals(PyOpenWorm.Network().aneuron('AVAL').name(), 'AVAL') self.assertEquals(PyOpenWorm.Network().aneuron('AVAR').name(), 'AVAR')
""" How to reference supporting evidence for some object in the database. See: "Metadata in PyOpenWorm" for discussion on semantics of what giving evidence for an object means. """ import sys import PyOpenWorm as P #Create dummy database configuration. d = P.Data({}) #Connect to database with dummy configuration P.connect(conf=d) #Create a new Neuron object to work with n = P.Neuron(name='AVAL') #Create a new Evidence object with `doi` and `pmid` fields populated. #See `PyOpenWorm/evidence.py` for other available fields. e = P.Evidence(doi='125.41.3/ploscompbiol', pmid='57182010') #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 #receptor UNC-8 on neuron AVAL. e.asserts(n.receptor('UNC-8')) #Save the Neuron and Evidence objects to the database. n.save()
""" 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
Note how the attributes of a neuron are accessed: `list(neuron.attribute())` where attribute is one of the attributes outlined in the neuron API. Also note that, for attributes with only one value, the value can be accessed by doing `neuron.attribute.one()`. Example: Something like `adal.name.one()` might return "ADAL", assuming we have declared the variable `adal`. """ from __future__ import print_function from __future__ import absolute_import import PyOpenWorm as P import os print(os.getcwd()) P.connect('default.conf') def get_names(it): res = [] for x in it: res.append(x.name()) return res w = P.Worm() net = w.neuron_network() print("Retrieving names...") inter = get_names(net.interneurons()) motor = get_names(net.motor()) sensory = get_names(net.sensory())
""" 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.
def tearDownClass(cls): PyOpenWorm.disconnect()
def tearDown(self): PyOpenWorm.disconnect()
def test_worm_muscles(self): self.assertTrue('MDL08' in PyOpenWorm.Worm().muscles()) self.assertTrue('MDL15' in PyOpenWorm.Worm().muscles())
def test_neuron_type(self): self.assertEquals(PyOpenWorm.Network().aneuron('AVAL').type(), 'interneuron') self.assertEquals(PyOpenWorm.Network().aneuron('DD5').type(), 'motor') self.assertEquals(PyOpenWorm.Network().aneuron('PHAL').type(), 'sensory')
Also note that, for attributes with only one value, the value can be accessed by doing `neuron.attribute.one()`. Example: Something like `adal.name.one()` might return "ADAL", assuming we have declared the variable `adal`. """ from __future__ import print_function from __future__ import absolute_import import PyOpenWorm as P from PyOpenWorm.worm import Worm from PyOpenWorm.context import Context from OpenWormData import BIO_ENT_NS import os print(os.getcwd()) conn = P.connect('default.conf') def get_names(it): res = [] for x in it: res.append(x.name()) return res ctx = Context(ident=BIO_ENT_NS['worm0'], conf=conn.conf).stored w = ctx(Worm)() net = w.neuron_network() print("Retrieving names...") inter = get_names(net.interneurons())
def test_neuron_Syn_degree(self): self.assertEquals(PyOpenWorm.Network().aneuron('AVAL').Syn_degree(), 74)
def setUpClass(self): PyOpenWorm.connect() PyOpenWorm.loadData(skipIfNewer=False) PyOpenWorm.disconnect() os.chdir('examples')
def test_neuron_receptors(self): self.assertTrue('GLR-2' in PyOpenWorm.Neuron('AVAL').receptors()) self.assertTrue('OSM-9' in PyOpenWorm.Neuron('PHAL').receptors())
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]
def test_neuron_get_reference(self): self.assertEquals( PyOpenWorm.Neuron('ADER').get_reference(0, 'EXP-1'), ['http://dx.doi.org/10.100.123/natneuro']) self.assertEquals( PyOpenWorm.Neuron('ADER').get_reference(0, 'DOP-2'), None)
def test_network(self): self.assertTrue(isinstance(PyOpenWorm.Network(), PyOpenWorm.Network))
def my_signal_handler(signal, frame): P.disconnect() sys.exit(0)
def test_network_aneuron(self): self.assertTrue( isinstance(PyOpenWorm.Network().aneuron('AVAL'), PyOpenWorm.Neuron))
def serialize_as_nquads(): P.config('rdf.graph').serialize('WormData.n4', format='nquads') print('serialized to nquads file')
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
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 P.connect('default.conf') class NC_neighbor(P.Property): def __init__(self, *args, **kwargs): P.Property.__init__(self, '_nb', *args, **kwargs) self.real_neighbor = self.owner.neighbor # Re-assigning neighbor Property self.owner.neighbor = self def get(self,**kwargs): # get the members of the class for x in self.owner.neighbor(): yield x def set(self, ob, **kwargs): self.real_neighbor(ob) if isinstance(ob, NeuronClass): ob_name = ob.name() this_name = self.owner.name() for x in ob.member(): # Get the name for the neighbor # XXX: try: n = x.name() side = n[n.find(ob_name)+len(ob_name):]
""" 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 __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")