class ExpressionPattern(BiologyType): class_context = BiologyType.class_context wormbaseid = DatatypeProperty() ''' The ID for the expression pattern in Wormbase ''' wormbaseID = Alias(wormbaseid) ''' Alias to :py:attr:`wormbaseid` ''' wormbaseURL = DatatypeProperty() ''' The URL for the expression pattern in Wormbase ''' description = DatatypeProperty() ''' Natural language description of the expression pattern ''' def __init__(self, wormbaseid=None, **kwargs): super(ExpressionPattern, self).__init__(**kwargs) if wormbaseid: self.wormbaseid(wormbaseid) self.wormbaseURL( R.URIRef("http://www.wormbase.org/species/all/expr_pattern/" + wormbaseid)) def defined_augment(self): return self.wormbaseid.has_defined_value() def identifier_augment(self): return self.make_identifier(self.wormbaseid.defined_values[0])
class Widget(DataObject): class_context = 'http://example.org/test_adding_data' rdf_type = 'http://example.org/BDW/schema/Widget' rdf_namespace = 'http://example.org/BDW/entities/Widget#' hardiness = DatatypeProperty() fullness = DatatypeProperty() part_number = DatatypeProperty() key_property = {'name': 'part_number', 'type': 'direct'}
class Muscle(Cell): """ A single muscle cell. See what neurons innervate a muscle: Example:: >>> mdr21 = Muscle('MDR21') >>> innervates_mdr21 = mdr21.innervatedBy() >>> len(innervates_mdr21) 4 """ class_context = Cell.class_context innervatedBy = ObjectProperty(value_type=Neuron, multiple=True) ''' Neurons synapsing with this muscle ''' neurons = Alias(innervatedBy) ''' Alias to `innervatedBy` ''' receptors = DatatypeProperty(multiple=True) ''' Receptor types expressed by this type of muscle ''' receptor = Alias(receptors) ''' Alias to `receptors` '''
class Monkey(DataObject): class_context = 'http://example.org/primate/monkey' bananas = DatatypeProperty() def identifier_augment(self): return type(self).rdf_namespace['paul'] def defined_augment(self): return True
class ModelDBPropertyClassDescription(ModelDB, PythonClassDescription): ''' Description of a `ModelDBDataSource` property ''' local_id = DatatypeProperty(__doc__='ID used on the page') display_name = DatatypeProperty(__doc__='Display name') key_properties = ('name', 'module', 'local_id') def resolve_class(self): local_id = self.local_id() if not local_id: raise ClassResolutionFailed('Missing local_id') display_name = self.display_name() if not display_name: raise ClassResolutionFailed('Missing display_name') return create_property_class(local_id, display_name)
class ChannelModel(DataObject): """ A model for an ion channel. There may be multiple models for a single channel. Example usage:: >>> from owmeta_core.quantity import Quantity # Create a ChannelModel >>> cm = PatchClampChannelModel(key='ca_boyle', ... gating='voltage', ... ion='Ca', ... conductance=Quantity.parse('10pS')) """ class_context = CONTEXT modelType = DatatypeProperty() ''' The type of model employed to describe a channel ''' ion = DatatypeProperty(multiple=True) ''' The type of ion this channel selects for ''' gating = DatatypeProperty(multiple=True) ''' The gating mechanism for this channel ("voltage" or name of ligand(s) ) ''' conductance = DatatypeProperty() ''' The conductance of this ion channel. This is the initial value, and should be entered as a Quantity object. ''' neuroML = CPThunk(NeuroMLProperty) def __init__(self, modelType=None, *args, **kwargs): super(ChannelModel, self).__init__(*args, **kwargs) #Change modelType value to something from ChannelModelType class on init if isinstance(modelType, six.string_types): modelType = modelType.lower() if modelType in ('homology', ChannelModelType.homologyEstimate): self.modelType(ChannelModelType.homologyEstimate) elif modelType in ('patch-clamp', ChannelModelType.patchClamp): self.modelType(ChannelModelType.patchClamp)
class Website(BaseDocument): """ A representation of a website """ class_context = SCI_CTX url = DatatypeProperty() ''' A URL for the website ''' title = DatatypeProperty() ''' The official name for the website ''' def __init__(self, title=None, **kwargs): super(Website, self).__init__(rdfs_comment=title, title=title, **kwargs) def defined_augment(self): return self.url.has_defined_value() def identifier_augment(self): return URIRef(self.url.defined_values[0].identifier)
class Donkey(DataObject): base_namespace = 'http://example.org/schema/' class_context = 'http://example.org/ungulate/donkey' bananas = DatatypeProperty() def identifier_augment(self): return type(self).rdf_namespace['danny'] def defined_augment(self): return True
class NeuroMLDocument(DataObject): ''' Represents a NeuroML document The document may be represented literally in the RDF graph using `xml_content` or stored elsewhere and included by reference with `document_url`. Example:: >>> embedded_nml = NeuroMLDocument(key='embedded_ex', content="""\\ ... <?xml version="1.0" encoding="UTF-8"?> ... <neuroml xmlns="http://www.neuroml.org/schema/neuroml2" ... xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ... xsi:schemaLocation="http://www.neuroml.org/schema/neuroml2 ... https://raw.github.com/NeuroML/NeuroML2/master/Schemas/NeuroML2/NeuroML_v2beta.xsd" ... id="k_slow"> ... <ionChannel id="k_slow" conductance="10pS" type="ionChannelHH" species="k"> ... <notes>K slow channel from Boyle and Cohen 2008</notes> ... <gateHHtauInf id="n" instances="1"> ... <timeCourse type="fixedTimeCourse" tau="25.0007 ms"/> ... <steadyState type="HHSigmoidVariable" rate="1" scale="15.8512 mV" midpoint="19.8741 mV"/> ... </gateHHtauInf> ... </ionChannel> ... </neuroml>""") >>> external_nml = NeuroMLDocument(ident='external_ex', ... document_url='') ''' class_context = CONTEXT content = DatatypeProperty() ''' XML content for the document. Should be a complete NeuroML document rather than a fragment. ''' document_url = DatatypeProperty(multiple=True) '''
class Channel(BiologyType): """ A biological ion channel. """ class_context = BiologyType.class_context rdf_type = CHANNEL_RDF_TYPE subfamily = DatatypeProperty() ''' Ion channel's subfamily ''' name = DatatypeProperty() ''' Ion channel's name ''' description = DatatypeProperty() ''' A description of the ion channel ''' gene_name = DatatypeProperty() ''' Name of the gene that codes for this ion channel ''' gene_class = DatatypeProperty() ''' Classification of the encoding gene ''' gene_WB_ID = DatatypeProperty() ''' Wormbase ID of the encoding gene ''' expression_pattern = ObjectProperty(multiple=True, value_type=ExpressionPattern) ''' A pattern of expression of this cell within an organism ''' proteins = DatatypeProperty(multiple=True) ''' Proteins associated with this channel ''' appearsIn = ObjectProperty(multiple=True, value_rdf_type=CELL_RDF_TYPE) ''' Cell types in which the ion channel has been expressed ''' model = ObjectProperty(value_type=ChannelModel) ''' Get experimental models of this ion channel ''' models = Alias(model) ''' Alias to :py:attr:`model` ''' def __init__(self, name=None, **kwargs): super(Channel, self).__init__(name=name, **kwargs) def defined_augment(self): return self.name.has_defined_value() def identifier_augment(self): return self.make_identifier(self.name.defined_values[0])
class A(DataObject): a = ObjectProperty() b = DatatypeProperty() key_properties = ('a', 'b')
class B(DataObject): prop = DatatypeProperty() key_properties = (prop, A.cookie)
class A(DataObject): cookie = DatatypeProperty()
class B(DataObject): a = DatatypeProperty() key_properties = (a, DatatypeProperty(name="cookie"))
class A(B): a = DatatypeProperty() key_properties = (a, B.prop)
class Document(BaseDocument): """ A representation of some document. Possible keys include:: pmid, pubmed: a pubmed id or url (e.g., 24098140) wbid, wormbase: a wormbase id or url (e.g., WBPaper00044287) doi: a Digitial Object id or url (e.g., s00454-010-9273-0) uri: a URI specific to the document, preferably usable for accessing the document """ class_context = SCI_CTX author = DatatypeProperty(multiple=True) ''' An author of the document ''' doi = DatatypeProperty() ''' A Digital Object Identifier (DOI), optional ''' uri = DatatypeProperty(multiple=True) ''' A non-standard URI for the document ''' wbid = DatatypeProperty() ''' An ID from WormBase.org that points to a record, optional ''' wormbaseid = Alias(wbid) ''' An alias to `wbid` ''' pmid = DatatypeProperty() ''' A PubMed ID (PMID) that points to a paper ''' year = DatatypeProperty() ''' The year (e.g., publication year) of the document ''' date = Alias(year) ''' Alias to year ''' title = DatatypeProperty() ''' The title of the document ''' def __init__( self, bibtex=None, doi=None, pubmed=None, wormbase=None, **kwargs): """ Parameters ---------- bibtex : string A string containing a single BibTeX entry. Parsed during initialization, but not saved thereafter. optional doi : string A Digital Object Identifier (DOI). optional pubmed : string A PubMed ID (PMID) or URL that points to a paper. Ignored if 'pmid' is provided. optional wormbase : string An ID or URL from WormBase that points to a record. Ignored if `wbid` or `wormbaseid` are provided. optional """ super(Document, self).__init__(**kwargs) self.id_precedence = ('doi', 'pmid', 'wbid', 'uri') if bibtex is not None: self.update_with_bibtex(bibtex) if pubmed is not None and not self.pmid.has_defined_value(): if pubmed[:4] == 'http': _tmp = _pubmed_uri_to_pmid(pubmed) if _tmp is None: raise ValueError("Couldn't convert Pubmed URL to a PubMed ID") pmid = _tmp else: pmid = pubmed self.pmid.set(pmid) if wormbase is not None and not self.wbid.has_defined_value(): if wormbase[:4] == 'http': _tmp = _wormbase_uri_to_wbid(wormbase) if _tmp is None: raise ValueError("Couldn't convert Wormbase URL to a Wormbase ID") wbid = _tmp else: wbid = wormbase self.wbid.set(wbid) if doi is not None: if doi[:4] == 'http': _tmp = _doi_uri_to_doi(doi) if _tmp is not None: doi = _tmp self.doi.set(doi) def update_with_bibtex(self, bibtex): bib_db = BIB.loads(bibtex) if len(bib_db.entries) > 1: raise ValueError('The given BibTex string has %d entries.' ' Cannot determine which entry to use for the document' % len(bib_db)) BIB.update_document_with_bibtex(self, bib_db.entries[0]) def defined_augment(self): for x in self.id_precedence: if getattr(self, x).has_defined_value(): return True return False def identifier_augment(self): for idKind in self.id_precedence: idprop = getattr(self, idKind) if idprop.has_defined_value(): s = str(idKind) + ":" + idprop.defined_values[0].identifier.n3() return self.make_identifier(s) raise IdentifierMissingException(self) # TODO: Provide a way to override modification of already set values. def update_from_wormbase(self, replace_existing=False): """ Queries wormbase for additional data to fill in the Document. If replace_existing is set to `True`, then existing values will be cleared. """ # XXX: wormbase's REST API is pretty sparse in terms of data provided. # Would be better off using AQL or the perl interface # _Very_ few of these have these fields filled in wbid = self.wbid.defined_values if len(wbid) == 1: wbid = wbid[0].identifier.toPython() # get the author try: root = self.conf.get('wormbase_api_root_url', 'http://rest.wormbase.org') url = root + '/rest/widget/paper/' + str(wbid) + '/overview?content-type=application%2Fjson' j = _json_request(url) if 'fields' in j: f = j['fields'] if 'authors' in f: dat = f['authors']['data'] if dat is not None: if replace_existing and self.author.has_defined_value: self.author.clear() for x in dat: self.author.set(x['label']) for fname in ('pmid', 'year', 'title', 'doi'): if fname in f and f[fname]['data'] is not None: attr = getattr(self, fname) if replace_existing and attr.has_defined_value: attr.clear() attr.set(f[fname]['data']) except Exception: logger.warning("Couldn't retrieve Wormbase data", exc_info=True) elif len(wbid) == 0: raise WormbaseRetrievalException("There is no Wormbase ID attached to this Document." " So no data can be retrieved") else: raise WormbaseRetrievalException("There is more than one Wormbase ID attached to this Document." " Please try with just one Wormbase ID") def _crossref_doi_extract(self): # Extract data from crossref def crRequest(doi): data = {'q': doi} data_encoded = urlencode(data) return _json_request( 'http://search.labs.crossref.org/dois?%s' % data_encoded) doi = self.doi() if doi[:4] == 'http': doi = _doi_uri_to_doi(doi) try: r = crRequest(doi) except Exception: logger.warning("Couldn't retrieve Crossref info", exc_info=True) return # XXX: I don't think coins is meant to be used, but it has structured # data... if len(r) > 0: extra_data = r[0]['coins'].split('&') fields = (x.split("=") for x in extra_data) fields = [[y.replace('+', ' ').strip() for y in x] for x in fields] authors = [x[1] for x in fields if x[0] == 'rft.au'] for a in authors: self.author(a) # no error for bad ids, just an empty list if len(r) > 0: # Crossref can process multiple doi's at one go and return the # metadata. we just need the first one r = r[0] if 'title' in r: self.title(r['title']) if 'year' in r: self.year(r['year']) def update_from_pubmed(self): def pmRequest(pmid): import xml.etree.ElementTree as ET # Python 2.5 and up url = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=' + str(pmid) key = self.get('pubmed.api_key', None) if key: url += '&api_key=' + key else: logger.warning("PubMed API key not defined. API calls will be limited.") s = _url_request(url) if hasattr(s, 'charset'): parser = ET.XMLParser(encoding=s.charset) else: parser = None return ET.parse(s, parser) pmid = self.pmid.defined_values if len(pmid) == 1: pmid = pmid[0].identifier.toPython() try: tree = pmRequest(pmid) except Exception: logger.warning("Couldn't retrieve Pubmed info", exc_info=True) return for x in tree.findall('./DocSum/Item[@Name="AuthorList"]/Item'): self.author(x.text) for x in tree.findall('./DocSum/Item[@Name="Title"]'): self.title(x.text) for x in tree.findall('./DocSum/Item[@Name="DOI"]'): self.doi(x.text) for x in tree.findall('./DocSum/Item[@Name="PubDate"]'): self.year(x.text) elif len(pmid) == 0: raise PubmedRetrievalException('No Pubmed ID is attached to this document. Cannot retrieve Pubmed data') else: raise PubmedRetrievalException('More than one Pubmed ID is attached to this document.' ' Please try with just one Pubmed ID')
class TDO(DataObject): rdf_type = 'http://openworm.org/entities/TDO' a = DatatypeProperty()
class A(DataObject): a = DatatypeProperty()
class Worm(BiologyType): """ A representation of the whole worm """ class_context = BiologyType.class_context rdf_type = WORM_RDF_TYPE scientific_name = DatatypeProperty() ''' Scientific name for the organism ''' name = Alias(scientific_name) ''' Alias to `scientific_name` ''' muscle = ObjectProperty(value_type=Muscle, multiple=True) ''' A type of muscle which is in the worm ''' cell = ObjectProperty(value_type=Cell) ''' A type of cell in the worm ''' neuron_network = ObjectProperty(value_type=Network, inverse_of=(Network, 'worm')) ''' The neuron network of the worm ''' def __init__(self, scientific_name=None, **kwargs): super(Worm, self).__init__(**kwargs) if scientific_name: self.scientific_name(scientific_name) else: self.scientific_name("C. elegans") def get_neuron_network(self): """ Return the neuron network of the worm. 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']) #show how many connections go out of AVAL >>> aval.connection.count('pre') 77 :returns: An object to work with the network of the worm :rtype: owmeta.Network """ return self.neuron_network() def muscles(self): """ Get all Muscle objects attached to the Worm. Example:: >>> muscles = P.Worm().muscles() >>> len(muscles) 96 :returns: A set of all muscles :rtype: :py:class:`set` """ return set(x for x in self._muscles_helper()) def _muscles_helper(self): for x in self.muscle.get(): yield x def get_semantic_net(self): """ Get the underlying semantic network as an RDFLib Graph :returns: A semantic network containing information about the worm :rtype: rdflib.ConjunctiveGraph """ return self.rdf def defined_augment(self): ''' True if the name is defined ''' return self.name.has_defined_value() def identifier_augment(self, *args, **kwargs): ''' Result is derived from the name property ''' return self.make_identifier(self.name.defined_values[0])
class A(DataObject): class_context = 'https://example.org/types' redness = DatatypeProperty() blueness = DatatypeProperty()
class PatchClampExperiment(Experiment): """ Store experimental conditions for a patch clamp experiment. """ class_context = CONTEXT Ca_concentration = DatatypeProperty() '''Calcium concentration''' Cl_concentration = DatatypeProperty() '''Chlorine concentration''' blockers = DatatypeProperty() '''Channel blockers used for this experiment''' cell = DatatypeProperty() '''The cell this experiment was performed on''' cell_age = DatatypeProperty() '''Age of the cell''' delta_t = DatatypeProperty() duration = DatatypeProperty() end_time = DatatypeProperty() extra_solution = DatatypeProperty() initial_voltage = DatatypeProperty() '''Starting voltage of the patch clamp''' ion_channel = DatatypeProperty() '''The ion channel being clamped''' membrane_capacitance = DatatypeProperty() '''Initial membrane capacitance''' mutants = DatatypeProperty() '''Type(s) of mutants being used in this experiment''' patch_type = DatatypeProperty() '''Type of patch clamp being used ('voltage' or 'current')''' pipette_solution = DatatypeProperty() '''Type of solution in the pipette''' protocol_end = DatatypeProperty() protocol_start = DatatypeProperty() protocol_step = DatatypeProperty() start_time = DatatypeProperty() temperature = DatatypeProperty() type = DatatypeProperty()
class Person(DataObject): class_context = 'http://example.org/Person' first_name = DatatypeProperty() last_name = DatatypeProperty()
class Plot(DataObject): """ Object for storing plot data in owmeta. Parameters ---------- data : 2D list (list of lists) List of XY coordinates for this Plot. Example usage :: >>> pl = Plot([[1, 2], [3, 4]]) >>> pl.get_data() # [[1, 2], [3, 4]] """ class_context = SCI_CTX _data_string = DatatypeProperty() def __init__(self, data=None, *args, **kwargs): super(Plot, self).__init__(*args, **kwargs) if data: self.set_data(data) def _to_string(self, input_list): """ Converts input_list to a string for serialized storage in owmeta. """ return '|'.join([str(item) for item in input_list]) def _to_list(self, input_string): """ Converts from internal serlialized string to a 2D list. """ if input_string is None: return None out_list = [] for pair_string in input_string.split('|'): pair_as_list = pair_string \ .replace('[', '') \ .replace(']', '') \ .split(',') out_list.append([float(x) for x in pair_as_list]) return out_list def set_data(self, data): """ Set the data attribute, which is user-facing, as well as the serialized _data_string attribute, which is used for db storage. """ try: # make sure we're dealing with a 2D list assert isinstance(data, list) assert isinstance(data[0], list) self._data_string(self._to_string(data)) self.data = data except (AssertionError, IndexError): raise ValueError('Attribute "data" must be a 2D list of numbers.') def get_data(self): """ Get the data stored for this plot. """ return self._to_list(self._data_string())
class A(DataObject): a = DatatypeProperty() properties_are_init_args = True
class B(A): b = DatatypeProperty() properties_are_init_args = False
class A(DataObject): a = DatatypeProperty() b = DatatypeProperty() key_properties = (a, b)
class Connection(BiologyType): class_context = BiologyType.class_context post_cell = ObjectProperty(value_type=Cell) ''' The post-synaptic cell ''' pre_cell = ObjectProperty(value_type=Cell) ''' The pre-synaptic cell ''' number = DatatypeProperty() ''' The weight of the connection ''' synclass = DatatypeProperty() ''' The kind of Neurotransmitter (if any) sent between `pre_cell` and `post_cell` ''' syntype = DatatypeProperty() ''' The kind of synaptic connection. 'gapJunction' indicates a gap junction and 'send' a chemical synapse ''' termination = DatatypeProperty() ''' Where the connection terminates. Inferred from type of post_cell at initialization ''' key_properties = (pre_cell, post_cell, syntype) # Arguments are given explicitly here to support positional arguments def __init__(self, pre_cell=None, post_cell=None, number=None, syntype=None, synclass=None, termination=None, **kwargs): super(Connection, self).__init__(pre_cell=pre_cell, post_cell=post_cell, number=number, syntype=syntype, synclass=synclass, **kwargs) if isinstance(termination, six.string_types): termination = termination.lower() if termination in ('neuron', Termination.Neuron): self.termination(Termination.Neuron) elif termination in ('muscle', Termination.Muscle): self.termination(Termination.Muscle) if isinstance(syntype, six.string_types): syntype = syntype.lower() if syntype in ('send', SynapseType.Chemical): self.syntype(SynapseType.Chemical) elif syntype in ('gapjunction', SynapseType.GapJunction): self.syntype(SynapseType.GapJunction) def __str__(self): nom = [] props = ( 'pre_cell', 'post_cell', 'syntype', 'termination', 'number', 'synclass', ) for p in props: if getattr(self, p).has_defined_value(): nom.append((p, getattr(self, p).defined_values[0])) if len(nom) == 0: return super(Connection, self).__str__() else: return 'Connection(' + \ ', '.join('{}={}'.format(n[0], n[1]) for n in nom) + \ ')'
class B(DataObject): prop = DatatypeProperty()
class Neuron(Cell): """ A neuron. See what neurons express some neuropeptide 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']) #show how many connections go out of AVAL >>> aval.connection.count('pre') 77 >>> aval.name() u'AVAL' #list all known receptors >>> sorted(aval.receptors()) [u'GGR-3', u'GLR-1', u'GLR-2', u'GLR-4', u'GLR-5', u'NMR-1', u'NMR-2', u'UNC-8'] #show how many chemical synapses go in and out of AVAL >>> aval.Syn_degree() 90 Parameters ---------- name : string The name of the neuron. Attributes ---------- neighbor : CustomProperty Get neurons connected to this neuron if called with no arguments, or with arguments, state that neuronName is a neighbor of this Neuron connection : CustomProperty Get a set of Connection objects describing chemical synapses or gap junctions between this neuron and others """ class_context = Cell.class_context type = DatatypeProperty(multiple=True) ''' The neuron type (i.e., sensory, interneuron, motor) ''' receptor = DatatypeProperty(multiple=True) ''' The receptor types associated with this neuron ''' innexin = DatatypeProperty(multiple=True) ''' Innexin types associated with this neuron ''' neurotransmitter = DatatypeProperty(multiple=True) ''' Neurotransmitters associated with this neuron ''' neuropeptide = DatatypeProperty(multiple=True) ''' Name of the gene corresponding to the neuropeptide produced by this neuron ''' receptors = Alias(receptor) ''' Alias to :py:attr:`receptor` ''' def __init__(self, name=None, **kwargs): super(Neuron, self).__init__(name=name, **kwargs) # Get neurons connected to this neuron Neighbor(owner=self) # Get connections from this neuron ConnectionProperty(owner=self) self.get_neighbors = self.neighbor def contextualize(self, context): res = super(Neuron, self).contextualize(context) if hasattr(self, 'neighbor'): res = NeuronProxy(self.neighbor.contextualize(context), self.connection.contextualize(context), res) return res def GJ_degree(self): """Get the degree of this neuron for gap junction edges only :returns: total number of incoming and outgoing gap junctions :rtype: int """ count = 0 for c in self.connection(): if c.syntype.one() == 'gapJunction': count += 1 return count def Syn_degree(self): """Get the degree of this neuron for chemical synapse edges only :returns: total number of incoming and outgoing chemical synapses :rtype: int """ count = 0 for c in self.connection.get('either'): if c.syntype.one() == 'send': count += 1 return count def get_incidents(self, type=0): """ Get neurons which synapse at this neuron """ # Directed graph. Getting accessible _from_ this node for item in self['nx'].in_edges_iter(self.name(), data=True): if 'GapJunction' in item[2]['synapse']: yield item[0]
class Cell(BiologyType): """ A biological cell. All cells with the same `name` are considered to be the same object. Parameters ----------- name : str The name of the cell lineageName : str The lineageName of the cell Examples -------- >>> from owmeta_core.quantity import Quantity >>> c = Cell(lineageName="AB plapaaaap", ... divisionVolume=Quantity("600","(um)^3")) """ class_context = BiologyType.class_context rdf_type = CELL_RDF_TYPE divisionVolume = DatatypeProperty() ''' The volume of the cell at division ''' name = DatatypeProperty() ''' The 'adult' name of the cell typically used by biologists when discussing C. elegans ''' wormbaseID = DatatypeProperty() description = DatatypeProperty() ''' A description of the cell ''' channel = ObjectProperty(value_type=Channel, multiple=True, inverse_of=(Channel, 'appearsIn')) lineageName = DatatypeProperty() ''' The lineageName of the cell ''' synonym = DatatypeProperty(multiple=True) daughterOf = ObjectProperty(value_type=This, inverse_of=(This, 'parentOf')) parentOf = ObjectProperty(value_type=This, multiple=True) key_property = {'property': name, 'type': 'direct'} def __init__(self, name=None, lineageName=None, **kwargs): # NOTE: We name the `name` and `lineageName` as positional parameters for # convenience super(Cell, self).__init__(name=name, lineageName=lineageName, **kwargs) def blast(self): """ Return the blast name. Example:: >>> c = Cell(name="ADAL", lineageName='AB ') >>> c.blast() 'AB' Note that this isn't a `~dataobject_property.Property`. It returns the blast cell part of a `lineageName` value. """ import re try: ln = self.lineageName() x = re.split("[. ]", ln) return x[0] except Exception: return "" def __str__(self): if self.name.has_defined_value(): return str(self.name.defined_values[0].idl) else: return super(Cell, self).__str__()