Inheritance diagram for CellMLToNektar.cellml_metadata.RdfProcessor:

[legend]

Public Member Functions
def	__init__ (self, name)

def	__getattribute__ (self, name)

def	METADATA_NAMES (self)

def	STIMULUS_NAMES (self)

def	get_rdf_from_model (self, cellml_model)

def	remove_model (self, cellml_model)

def	update_serialized_rdf (self, cellml_model)

def	create_rdf_node (self, node_content=None, fragment_id=None)

def	create_unique_id (self, cellml_model, base_id)

def	add_statement (self, cellml_model, source, property, target)

def	replace_statement (self, cellml_model, source, property, target)

def	remove_statements (self, cellml_model, source, property, target)

def	get_target (self, cellml_model, source, property)

def	get_targets (self, cellml_model, source, property)

def	find_variables (self, cellml_model, property, value=None)

def	get_all_rdf (self, cellml_model)

def	namespace_member (self, node, nsuri, not_uri_ok=False, wrong_ns_ok=False)

Public Attributes
	Graph

Private Member Functions
def	_debug (*args)

def	_load_ontology (self)

def	_create_new_store (self, cellml_model)

def	_add_rdf_element (self, cellml_model, rdf_text)

def	_serialize (self, cellml_model)

Private Attributes
	_module

	_initializing

	_models

	_metadata_names

	_stimulus_names

Detailed Description

Implements CellML metadata functionality using the RDFLib library.

Definition at line 61 of file cellml_metadata.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.cellml_metadata.RdfProcessor.__init__	(	self,
		name
	)

Create the wrapper.

Definition at line 63 of file cellml_metadata.py.

    def __init__(self, name):
        """Create the wrapper."""
        # Magic for pretending to be a module
        self._module = sys.modules[name]
        sys.modules[name] = self
        self._initializing = True
        # Map from cellml_model instances to RDF stores
        self._models = {}
        # Oxford metadata will be loaded lazily
        self._metadata_names = self._stimulus_names = None
        # Cope with differences in API between library versions
        rdflib_major_version = int(rdflib.__version__[0])
        if rdflib_major_version >= 3:
            self.Graph = rdflib.Graph
        else:
            self.Graph = rdflib.ConjunctiveGraph
 

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.__getattribute__().

Member Function Documentation

◆ getattribute()

def CellMLToNektar.cellml_metadata.RdfProcessor.__getattribute__	(	self,
		name
	)

Provide access to real module-level variables as though they're class properties.

Definition at line 80 of file cellml_metadata.py.

    def __getattribute__(self, name):
        """Provide access to real module-level variables as though they're class properties."""
        # call module.__init__ after import introspection is done
        baseget = super(RdfProcessor, self).__getattribute__
        module = baseget('_module')
        if baseget('_initializing') and not name[:2] == '__' == name[-2:]:
            setattr(self, '_initializing', False)
            __init__(module)
        try:
            return baseget(name)
        except AttributeError:
            return getattr(module, name)
 

References CellMLToNektar.cellml_metadata.RdfProcessor.__init__().

◆ _add_rdf_element()

def CellMLToNektar.cellml_metadata.RdfProcessor._add_rdf_element	(	self,
		cellml_model,
		rdf_text
	)

private

Add statements to the model's graph from the given serialized RDF.

Definition at line 143 of file cellml_metadata.py.

    def _add_rdf_element(self, cellml_model, rdf_text):
        """Add statements to the model's graph from the given serialized RDF."""
        g = self.Graph()
        g.parse(StringIO(rdf_text))
        rdf_model = self._models[cellml_model]
        for stmt in g:
            rdf_model.add(stmt)
    

References CellMLToNektar.cellml_metadata.RdfProcessor._models, Nektar::LibUtilities::Graph.Graph(), and CellMLToNektar.cellml_metadata.RdfProcessor.Graph.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

◆ _create_new_store()

def CellMLToNektar.cellml_metadata.RdfProcessor._create_new_store	(	self,
		cellml_model
	)

private

Create a new RDF store for the given CellML model.
The new store will be available as self._models[cellml_model].

Definition at line 137 of file cellml_metadata.py.

    def _create_new_store(self, cellml_model):
        """Create a new RDF store for the given CellML model.
        The new store will be available as self._models[cellml_model].
        """
        self._models[cellml_model] = self.Graph()
    

References CellMLToNektar.cellml_metadata.RdfProcessor._models, Nektar::LibUtilities::Graph.Graph(), and CellMLToNektar.cellml_metadata.RdfProcessor.Graph.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

◆ _debug()

def CellMLToNektar.cellml_metadata.RdfProcessor._debug ( * args )

private

Definition at line 93 of file cellml_metadata.py.

    def _debug(*args):
        pycml.DEBUG('cellml-metadata', *args)
 

Referenced by CellMLToNektar.optimize.PartialEvaluator._check_retargetting(), CellMLToNektar.optimize.PartialEvaluator._do_reduce_eval_loop(), CellMLToNektar.optimize.PartialEvaluator._reduce_evaluate_expression(), CellMLToNektar.optimize.PartialEvaluator._rename_var(), CellMLToNektar.cellml_metadata.RdfProcessor.add_statement(), CellMLToNektar.cellml_metadata.RdfProcessor.find_variables(), CellMLToNektar.cellml_metadata.RdfProcessor.get_target(), CellMLToNektar.cellml_metadata.RdfProcessor.namespace_member(), CellMLToNektar.cellml_metadata.RdfProcessor.remove_model(), CellMLToNektar.cellml_metadata.RdfProcessor.remove_statements(), and CellMLToNektar.cellml_metadata.RdfProcessor.replace_statement().

◆ _load_ontology()

def CellMLToNektar.cellml_metadata.RdfProcessor._load_ontology ( self )

private

Load the Oxford metadata ontology the first time it's needed.

Definition at line 96 of file cellml_metadata.py.

    def _load_ontology(self):
        """Load the Oxford metadata ontology the first time it's needed."""
        pycml_path = os.path.dirname(os.path.realpath(__file__))
        oxmeta_ttl = os.path.join(pycml_path, 'oxford-metadata.ttl')
        oxmeta_rdf = os.path.join(pycml_path, 'oxford-metadata.rdf')
 
        g = self.Graph()
        # We allow a difference in modification time of 10s, so we don't get confused when checking out!
        if os.stat(oxmeta_ttl).st_mtime > os.stat(oxmeta_rdf).st_mtime + 10.0:
            # Try to regenerate RDF/XML version of ontology
            try:
                g.parse(oxmeta_ttl, format='turtle')
            except Exception, e:
                print >> sys.stderr, 'Unable to convert metadata from Turtle format to RDF/XML.'
                print >> sys.stderr, 'Probably you need to upgrade rdflib to version 4.\nDetails of error:'
                raise
            g.serialize(oxmeta_rdf, format='xml')
        else:
            # Just parse the RDF/XML version
            g.parse(oxmeta_rdf, format='xml')
        
        annotation_terms = list(g.subjects(rdflib.RDF.type, rdflib.URIRef(pycml.NSS['oxmeta']+u'Annotation')))
        self._metadata_names = frozenset(map(lambda node: self.namespace_member(node, pycml.NSS['oxmeta']), annotation_terms))
        
        # Parameters for the stimulus current
        self._stimulus_names = frozenset(filter(lambda name: name.startswith('membrane_stimulus_current_'), self._metadata_names))
 

References CellMLToNektar.cellml_metadata.RdfProcessor._metadata_names, CellMLToNektar.cellml_metadata.RdfProcessor._stimulus_names, Nektar::LibUtilities::Graph.Graph(), CellMLToNektar.cellml_metadata.RdfProcessor.Graph, and CellMLToNektar.cellml_metadata.RdfProcessor.namespace_member().

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.METADATA_NAMES(), and CellMLToNektar.cellml_metadata.RdfProcessor.STIMULUS_NAMES().

◆ _serialize()

def CellMLToNektar.cellml_metadata.RdfProcessor._serialize	(	self,
		cellml_model
	)

private

Serialize the RDF model for this CellML model to XML.

Definition at line 151 of file cellml_metadata.py.

    def _serialize(self, cellml_model):
        """Serialize the RDF model for this CellML model to XML."""
        return self._models[cellml_model].serialize()
    

References CellMLToNektar.cellml_metadata.RdfProcessor._models.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.update_serialized_rdf().

◆ add_statement()

def CellMLToNektar.cellml_metadata.RdfProcessor.add_statement	(	self,
		cellml_model,
		source,
		property,
		target
	)

Add a statement to the model.

Definition at line 240 of file cellml_metadata.py.

    def add_statement(self, cellml_model, source, property, target):
        """Add a statement to the model."""
        self._debug("add_statement(", source, ",", property, ",", target, ")")
        rdf_model = self.get_rdf_from_model(cellml_model)
        rdf_model.add((source, property, target))
 

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), and CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

◆ create_rdf_node()

def CellMLToNektar.cellml_metadata.RdfProcessor.create_rdf_node	(	self,
		node_content = `None`,
		fragment_id = `None`
	)

Create an RDF node.

node_content, if given, must either be a tuple (qname, namespace_uri),
or a string, in which case it is interpreted as a literal RDF node.

Alternatively, fragment_id may be given to refer to a cmeta:id within the
current model.

If neither are given, a blank node is created.

Definition at line 197 of file cellml_metadata.py.

    def create_rdf_node(self, node_content=None, fragment_id=None):
        """Create an RDF node.
        
        node_content, if given, must either be a tuple (qname, namespace_uri),
        or a string, in which case it is interpreted as a literal RDF node.
        
        Alternatively, fragment_id may be given to refer to a cmeta:id within the
        current model.
        
        If neither are given, a blank node is created.
        """
        if fragment_id:
            node = rdflib.URIRef(str('#'+fragment_id))
        elif node_content:
            if type(node_content) == types.TupleType:
                qname, nsuri = node_content
                if nsuri[-1] not in ['#', '/']:
                    nsuri = nsuri + '#'
                ns = rdflib.Namespace(nsuri)
                prefix, local_name = pycml.SplitQName(qname)
                node = ns[local_name]
            elif type(node_content) in types.StringTypes:
                node = rdflib.Literal(node_content)
            else:
                raise ValueError("Don't know how to make a node from " + str(node_content)
                                 + " of type " + type(node_content))
        else:
            node = rdflib.BNode()
        return node
 

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.create_unique_id(), and CellMLToNektar.cellml_metadata.RdfProcessor.find_variables().

◆ create_unique_id()

def CellMLToNektar.cellml_metadata.RdfProcessor.create_unique_id	(	self,
		cellml_model,
		base_id
	)

Create a fragment identifier that hasn't already been used.

If base_id hasn't been used, it will be returned.  Otherwise, underscores will
be added until a unique id is obtained.

Definition at line 227 of file cellml_metadata.py.

    def create_unique_id(self, cellml_model, base_id):
        """Create a fragment identifier that hasn't already been used.
        
        If base_id hasn't been used, it will be returned.  Otherwise, underscores will
        be added until a unique id is obtained.
        """
        while True:
            node = self.create_rdf_node(fragment_id=base_id)
            if not self.get_targets(cellml_model, node, None):
                break
            base_id += u'_'
        return base_id
 

References CellMLToNektar.cellml_metadata.RdfProcessor.create_rdf_node(), and CellMLToNektar.cellml_metadata.RdfProcessor.get_targets().

◆ find_variables()

def CellMLToNektar.cellml_metadata.RdfProcessor.find_variables	(	self,
		cellml_model,
		property,
		value = `None`
	)

Find variables in the cellml_model with the given property, and optionally value.

property (and value if given) should be a suitable input for create_rdf_node.

Will return a list of cellml_variable instances.

Definition at line 298 of file cellml_metadata.py.

    def find_variables(self, cellml_model, property, value=None):
        """Find variables in the cellml_model with the given property, and optionally value.
        
        property (and value if given) should be a suitable input for create_rdf_node.
        
        Will return a list of cellml_variable instances.
        """
        self._debug("find_variables(", property, ",", value, ")")
        rdf_model = self.get_rdf_from_model(cellml_model)
        property = self.create_rdf_node(property)
        if value:
            value = self.create_rdf_node(value)
        vars = []
        for result in rdf_model.subjects(property, value):
            assert isinstance(result, rdflib.URIRef), "Non-resource annotated."
            uri = str(result)
            assert uri[0] == '#', "Annotation found on non-local URI"
            var_id = uri[1:] # Strip '#'
            var_objs = cellml_model.xml_xpath(u'*/cml:variable[@cmeta:id="%s"]' % var_id)
            assert len(var_objs) == 1, "Didn't find a unique variable with ID " + var_id
            vars.append(var_objs[0])
        return vars
    

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), CellMLToNektar.cellml_metadata.RdfProcessor.create_rdf_node(), and CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

◆ get_all_rdf()

def CellMLToNektar.cellml_metadata.RdfProcessor.get_all_rdf	(	self,
		cellml_model
	)

Return an iterator over all RDF triples in the model.

Definition at line 321 of file cellml_metadata.py.

    def get_all_rdf(self, cellml_model):
        """Return an iterator over all RDF triples in the model."""
        rdf_model = self.get_rdf_from_model(cellml_model)
        for triple in rdf_model:
            yield triple
 

References CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

◆ get_rdf_from_model()

def CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model	(	self,
		cellml_model
	)

Get the RDF graph of the given CellML model.

If this model is already in our map, return the existing RDF store.
Otherwise, extract metadata from all RDF elements in the cellml_model,
create a new RDF graph from these, and delete the original elements.

Definition at line 155 of file cellml_metadata.py.

    def get_rdf_from_model(self, cellml_model):
        """Get the RDF graph of the given CellML model.
    
        If this model is already in our map, return the existing RDF store.
        Otherwise, extract metadata from all RDF elements in the cellml_model,
        create a new RDF graph from these, and delete the original elements.
        """
        if not cellml_model in self._models:
            rdf_blocks = cellml_model.xml_xpath(u'//rdf:RDF')
            self._create_new_store(cellml_model)
            for rdf_block in rdf_blocks:
                rdf_text = rdf_block.xml()
                self._add_rdf_element(cellml_model, rdf_text)
                rdf_block.xml_parent.xml_remove_child(rdf_block)
        return self._models[cellml_model]
 

References CellMLToNektar.cellml_metadata.RdfProcessor._add_rdf_element(), CellMLToNektar.cellml_metadata.RdfProcessor._create_new_store(), and CellMLToNektar.cellml_metadata.RdfProcessor._models.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.add_statement(), CellMLToNektar.cellml_metadata.RdfProcessor.find_variables(), CellMLToNektar.cellml_metadata.RdfProcessor.get_all_rdf(), CellMLToNektar.cellml_metadata.RdfProcessor.get_target(), CellMLToNektar.cellml_metadata.RdfProcessor.get_targets(), CellMLToNektar.cellml_metadata.RdfProcessor.remove_statements(), and CellMLToNektar.cellml_metadata.RdfProcessor.replace_statement().

◆ get_target()

def CellMLToNektar.cellml_metadata.RdfProcessor.get_target	(	self,
		cellml_model,
		source,
		property
	)

Get the target of property from source.

Returns None if no such target exists.  Throws if there is more than one match.

If the target is a literal node, returns its string value.  Otherwise returns an RDF node.

Definition at line 264 of file cellml_metadata.py.

    def get_target(self, cellml_model, source, property):
        """Get the target of property from source.
        
        Returns None if no such target exists.  Throws if there is more than one match.
        
        If the target is a literal node, returns its string value.  Otherwise returns an RDF node.
        """
        rdf_model = self.get_rdf_from_model(cellml_model)
        try:
            target = rdf_model.value(subject=source, predicate=property, any=False)
        except rdflib.exceptions.UniquenessError:
            raise ValueError("Too many targets for source " + str(source) + " and property " + str(property))
        if isinstance(target, rdflib.Literal):
            target = str(target)
        self._debug("get_target(", source, ",", property, ") -> ", "'" + str(target) + "'")
        return target
 

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), and CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

◆ get_targets()

def CellMLToNektar.cellml_metadata.RdfProcessor.get_targets	(	self,
		cellml_model,
		source,
		property
	)

Get a list of all targets of property from source.

If no such targets exist, returns an empty list.
If property is None, targets of any property will be returned.
Alternatively if source is None, targets of the given property from any source will be found.

For each target, if it is a literal node then its string value is given.
Otherwise the list will contain an RDF node.

Definition at line 281 of file cellml_metadata.py.

    def get_targets(self, cellml_model, source, property):
        """Get a list of all targets of property from source.
        
        If no such targets exist, returns an empty list.
        If property is None, targets of any property will be returned.
        Alternatively if source is None, targets of the given property from any source will be found.
        
        For each target, if it is a literal node then its string value is given.
        Otherwise the list will contain an RDF node.
        """
        rdf_model = self.get_rdf_from_model(cellml_model)
        targets = list(rdf_model.objects(subject=source, predicate=property))
        for i, target in enumerate(targets):
            if isinstance(target, rdflib.Literal):
                targets[i] = str(target)
        return targets
 

References CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.create_unique_id().

◆ METADATA_NAMES()

def CellMLToNektar.cellml_metadata.RdfProcessor.METADATA_NAMES ( self )

Fake a module-level constant as a property for lazy loading.

Definition at line 124 of file cellml_metadata.py.

    def METADATA_NAMES(self):
        """Fake a module-level constant as a property for lazy loading."""
        if self._metadata_names is None:
            self._load_ontology()
        return self._metadata_names
 

References CellMLToNektar.cellml_metadata.RdfProcessor._load_ontology(), and CellMLToNektar.cellml_metadata.RdfProcessor._metadata_names.

◆ namespace_member()

def CellMLToNektar.cellml_metadata.RdfProcessor.namespace_member	(	self,
		node,
		nsuri,
		not_uri_ok = `False`,
		wrong_ns_ok = `False`
	)

Given a URI reference RDF node and namespace URI, return the local part.

Will raise an exception if node is not a URI reference unless not_uri_ok is True.
Will raise an exception if the node doesn't live in the given namespace, unless
wrong_ns_ok is True.  In both cases, if the error is suppressed the empty string
will be returned instead.

Definition at line 327 of file cellml_metadata.py.

    def namespace_member(self, node, nsuri, not_uri_ok=False, wrong_ns_ok=False):
        """Given a URI reference RDF node and namespace URI, return the local part.
        
        Will raise an exception if node is not a URI reference unless not_uri_ok is True.
        Will raise an exception if the node doesn't live in the given namespace, unless
        wrong_ns_ok is True.  In both cases, if the error is suppressed the empty string
        will be returned instead.
        """
        local_part = ""
        if not isinstance(node, rdflib.URIRef):
            if not not_uri_ok:
                raise ValueError("Cannot extract namespace member for a non-URI RDF node.")
        if node.startswith(nsuri):
            local_part = node[len(nsuri):]
        elif not wrong_ns_ok:
            raise ValueError("Node is not in correct namespace.")
        self._debug("namespace_member(", node, ",", nsuri, ") = ", local_part)
        return local_part
 

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), and CellMLToNektar.optimize.PartialEvaluator._debug().

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor._load_ontology().

◆ remove_model()

def CellMLToNektar.cellml_metadata.RdfProcessor.remove_model	(	self,
		cellml_model
	)

The given model is being deleted / no longer needed.

Definition at line 171 of file cellml_metadata.py.

    def remove_model(self, cellml_model):
        """The given model is being deleted / no longer needed."""
        if cellml_model in self._models:
            del self._models[cellml_model]
            self._debug('Clearing RDF state for model', cellml_model.name)
 

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), and CellMLToNektar.cellml_metadata.RdfProcessor._models.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor.update_serialized_rdf().

◆ remove_statements()

def CellMLToNektar.cellml_metadata.RdfProcessor.remove_statements	(	self,
		cellml_model,
		source,
		property,
		target
	)

Remove all statements matching (source,property,target).

Any of these may be None to match anything.

Definition at line 255 of file cellml_metadata.py.

    def remove_statements(self, cellml_model, source, property, target):
        """Remove all statements matching (source,property,target).
        
        Any of these may be None to match anything.
        """
        self._debug("remove_statements(", source, ",", property, ",", target, ")")
        rdf_model = self.get_rdf_from_model(cellml_model)
        rdf_model.remove((source, property, target))
 

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), and CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

◆ replace_statement()

def CellMLToNektar.cellml_metadata.RdfProcessor.replace_statement	(	self,
		cellml_model,
		source,
		property,
		target
	)

Add a statement to the model, avoiding duplicates.

Any existing statements with the same source and property will first be removed.

Definition at line 246 of file cellml_metadata.py.

    def replace_statement(self, cellml_model, source, property, target):
        """Add a statement to the model, avoiding duplicates.
        
        Any existing statements with the same source and property will first be removed.
        """
        self._debug("replace_statement(", source, ",", property, ",", target, ")")
        rdf_model = self.get_rdf_from_model(cellml_model)
        rdf_model.set((source, property, target))
 

References CellMLToNektar.cellml_metadata.RdfProcessor._debug(), CellMLToNektar.optimize.PartialEvaluator._debug(), and CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model().

◆ STIMULUS_NAMES()

def CellMLToNektar.cellml_metadata.RdfProcessor.STIMULUS_NAMES ( self )

Fake a module-level constant as a property for lazy loading.

Definition at line 131 of file cellml_metadata.py.

    def STIMULUS_NAMES(self):
        """Fake a module-level constant as a property for lazy loading."""
        if self._stimulus_names is None:
            self._load_ontology()
        return self._stimulus_names
 

References CellMLToNektar.cellml_metadata.RdfProcessor._load_ontology(), and CellMLToNektar.cellml_metadata.RdfProcessor._stimulus_names.

◆ update_serialized_rdf()

def CellMLToNektar.cellml_metadata.RdfProcessor.update_serialized_rdf	(	self,
		cellml_model
	)

Ensure the RDF serialized into the given CellML model is up-to-date.

If we have done any metadata processing on the given model, will serialize
our RDF store into the rdf:RDF element child of the model.

Definition at line 177 of file cellml_metadata.py.

    def update_serialized_rdf(self, cellml_model):
        """Ensure the RDF serialized into the given CellML model is up-to-date.
        
        If we have done any metadata processing on the given model, will serialize
        our RDF store into the rdf:RDF element child of the model.
        """
        if cellml_model in self._models:
            # Paranoia: ensure it doesn't already contain serialized RDF
            rdf_blocks = cellml_model.xml_xpath(u'//rdf:RDF')
            if rdf_blocks:
                pycml.LOG('cellml-metadata', logging.WARNING, 'Removing existing RDF in model.')
                for rdf_block in rdf_blocks:
                    rdf_block.xml_parent.xml_remove_child(rdf_block)
            # Serialize the RDF model into cellml_model.RDF
            rdf_text = self._serialize(cellml_model)
            rdf_doc = pycml.amara.parse(rdf_text)
            cellml_model.xml_append(rdf_doc.RDF)
            # Remove the RDF model
            self.remove_model(cellml_model)
 

References CellMLToNektar.cellml_metadata.RdfProcessor._models, CellMLToNektar.cellml_metadata.RdfProcessor._serialize(), and CellMLToNektar.cellml_metadata.RdfProcessor.remove_model().

Member Data Documentation

◆ _initializing

CellMLToNektar.cellml_metadata.RdfProcessor._initializing

private

Definition at line 68 of file cellml_metadata.py.

◆ _metadata_names

CellMLToNektar.cellml_metadata.RdfProcessor._metadata_names

private

Definition at line 72 of file cellml_metadata.py.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor._load_ontology(), and CellMLToNektar.cellml_metadata.RdfProcessor.METADATA_NAMES().

◆ _models

CellMLToNektar.cellml_metadata.RdfProcessor._models

private

Definition at line 70 of file cellml_metadata.py.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor._add_rdf_element(), CellMLToNektar.cellml_metadata.RdfProcessor._create_new_store(), CellMLToNektar.cellml_metadata.RdfProcessor._serialize(), CellMLToNektar.cellml_metadata.RdfProcessor.get_rdf_from_model(), CellMLToNektar.cellml_metadata.RdfProcessor.remove_model(), and CellMLToNektar.cellml_metadata.RdfProcessor.update_serialized_rdf().

◆ _module

CellMLToNektar.cellml_metadata.RdfProcessor._module

private

Definition at line 66 of file cellml_metadata.py.

◆ _stimulus_names

CellMLToNektar.cellml_metadata.RdfProcessor._stimulus_names

private

Definition at line 72 of file cellml_metadata.py.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor._load_ontology(), and CellMLToNektar.cellml_metadata.RdfProcessor.STIMULUS_NAMES().

◆ Graph

CellMLToNektar.cellml_metadata.RdfProcessor.Graph

Definition at line 76 of file cellml_metadata.py.

Referenced by CellMLToNektar.cellml_metadata.RdfProcessor._add_rdf_element(), CellMLToNektar.cellml_metadata.RdfProcessor._create_new_store(), and CellMLToNektar.cellml_metadata.RdfProcessor._load_ontology().

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __getattribute__()

◆ _add_rdf_element()

◆ _create_new_store()

◆ _debug()

◆ _load_ontology()

◆ _serialize()

◆ add_statement()

◆ create_rdf_node()

◆ create_unique_id()

◆ find_variables()

◆ get_all_rdf()

◆ get_rdf_from_model()

◆ get_target()

◆ get_targets()

◆ METADATA_NAMES()

◆ namespace_member()

◆ remove_model()

◆ remove_statements()

◆ replace_statement()

◆ STIMULUS_NAMES()

◆ update_serialized_rdf()

Member Data Documentation

◆ _initializing

◆ _metadata_names

◆ _models

◆ _module

◆ _stimulus_names

◆ Graph

◆ init()

◆ getattribute()