def add_node_attribute(self, iri: Union[URIRef, str], key: str, value: str) -> None:
"""
Add an attribute to a node, while taking into account whether the attribute
should be multi-valued.
Multi-valued properties will not contain duplicates.
The ``key`` may be a rdflib.URIRef or a URI string that maps onto a property name
as defined in ``rdf_utils.property_mapping``.
If the node does not exist then it is created using the given ``iri``.
Parameters
----------
iri: Union[rdflib.URIRef, str]
The IRI of a node in the rdflib.Graph
key: str
The name of the attribute. Can be a rdflib.URIRef or URI string
value: str
The value of the attribute
"""
if not isinstance(key, URIRef):
key = URIRef(key)
mapped_key = property_mapping.get(key)
if not mapped_key:
logging.debug(f"{key} could not be mapped; using {key}")
mapped_key = key
n = self.prefix_manager.contract(str(iri))
if self.graph.has_node(n):
attr_dict = self.graph.nodes[n]
else:
self.add_node(n)
attr_dict = {'id': n}
self._add_attribute(attr_dict, mapped_key, str(value))
def add_node_attribute(self, iri: URIRef, key: str, value: str) -> None:
"""
Add an attribute to a node, while taking into account whether the attribute
should be multi-valued.
Multi-valued properties will not contain duplicates.
The key may be a rdflib.URIRef or a URI string that maps onto a property name
as defined in `rdf_utils.property_mapping`.
If the node does not exist then it is created using the given iri.
Parameters
----------
iri: rdflib.URIRef
The IRI of a node in the rdflib.Graph
key: str
The name of the attribute. Can be a rdflib.URIRef or URI string
value: str
The value of the attribute
"""
if key.lower() in is_property_multivalued:
key = key.lower()
else:
if not isinstance(key, URIRef):
key = URIRef(key)
key = property_mapping.get(key)
if key is not None:
n = self.add_node(iri)
attr_dict = self.graph.node[n]
self._add_attribute(attr_dict, key, value)
def add_edge_attribute(self, subject_iri: Union[URIRef, str],
object_iri: URIRef, predicate_iri: URIRef, key: str,
value: str) -> None:
"""
Adds an attribute to an edge, while taking into account whether the attribute
should be multi-valued.
Multi-valued properties will not contain duplicates.
The key may be a rdflib.URIRef or a URI string that maps onto a property name
as defined in `rdf_utils.property_mapping`.
If the nodes in the edge does not exist then they will be created
using subject_iri and object_iri.
If the edge itself does not exist then it will be created using
subject_iri, object_iri and predicate_iri.
Parameters
----------
subject_iri: [rdflib.URIRef, str]
The IRI of the subject node of an edge in rdflib.Graph
object_iri: rdflib.URIRef
The IRI of the object node of an edge in rdflib.Graph
predicate_iri: rdflib.URIRef
The IRI of the predicate representing an edge in rdflib.Graph
key: str
The name of the attribute. Can be a rdflib.URIRef or URI string
value: str
The value of the attribute
"""
if key.lower() in is_property_multivalued:
key = key.lower()
else:
if not isinstance(key, URIRef):
key = URIRef(key)
key = property_mapping.get(key)
if key is not None:
subject_curie = make_curie(subject_iri)
object_curie = make_curie(object_iri)
edge_label = process_iri(predicate_iri)
if is_curie(edge_label):
edge_label = curie_lookup(edge_label)
edge_key = generate_edge_key(subject_curie, edge_label,
object_curie)
attr_dict = self.graph.get_edge_data(subject_curie,
object_curie,
key=edge_key)
self._add_attribute(attr_dict, key, value)
def load_networkx_graph(self,
rdfgraph: rdflib.Graph = None,
predicates: Set[URIRef] = None,
**kwargs) -> None:
"""
Walk through the rdflib.Graph and load all triples into networkx.MultiDiGraph
Parameters
----------
rdfgraph: rdflib.Graph
Graph containing nodes and edges
predicates: list
A list of rdflib.URIRef representing predicates to be loaded
kwargs: dict
Any additional arguments
"""
if not predicates:
predicates = set()
predicates = predicates.union(self.OWL_PREDICATES)
for rel in predicates:
triples = rdfgraph.triples((None, rel, None))
with click.progressbar(
list(triples),
label="Loading relation '{}'".format(rel)) as bar:
for s, p, o in bar:
if not (isinstance(s, rdflib.term.BNode)
and isinstance(o, rdflib.term.BNode)):
self.add_edge(s, o, p)
# get all OBAN.associations
associations = rdfgraph.subjects(RDF.type, OBAN.association)
logging.info("Loading from rdflib.Graph into networkx.MultiDiGraph")
with click.progressbar(list(associations), label='Progress') as bar:
for association in bar:
edge_attr = defaultdict(list)
edge_attr['id'].append(str(association))
# dereify OBAN.association
subject = None
object = None
predicate = None
# get all triples for association
for s, p, o in rdfgraph.triples((association, None, None)):
if o.startswith(PMID):
edge_attr['publications'].append(o)
if p in property_mapping or isinstance(
o, rdflib.term.Literal):
p = property_mapping.get(p, p)
if p == 'subject':
subject = o
elif p == 'object':
object = o
elif p == 'predicate':
predicate = o
else:
edge_attr[p].append(o)
if predicate is None:
logging.warning(
"No 'predicate' for OBAN.association {}; defaulting to '{}'"
.format(association, self.DEFAULT_EDGE_LABEL))
predicate = DEFAULT_EDGE_LABEL
if subject and object:
self.add_edge(subject, object, predicate)
for key, values in edge_attr.items():
for value in values:
self.add_edge_attribute(subject,
object,
predicate,
key=key,
value=value)