def to_graph(self,
graph=None,
node=None,
td_nodes=None,
th_nodes=None,
abstract=False,
**kwargs):
# type: (Graph, Node, dict, dict, bool, dict) -> Graph
if node is None:
node = self.node or BNode()
if graph is None:
graph = bound_graph(str(node))
if td_nodes is None:
td_nodes = {td: td.node for td in self.tds}
if th_nodes is None:
th_nodes = {r: r.node for r in self.resources}
graph.add((node, RDF.type, CORE.Ecosystem))
roots = self.roots
for td in self.tds:
if td in roots:
graph.add(
(node, CORE.hasComponent, td.resource.node if not th_nodes
else th_nodes.get(td.resource.node, td.resource.node)))
if not abstract:
td_node = td_nodes.get(td, None) if td_nodes else None
for ext in td.extends:
ext.to_graph(graph=graph,
node=ext.node,
td_nodes=td_nodes,
th_nodes=th_nodes,
**kwargs)
td.to_graph(graph=graph,
node=td_node,
td_nodes=td_nodes,
th_nodes=th_nodes,
**kwargs)
for root in self.non_td_root_resources:
graph.add((node, CORE.hasComponent, root.node))
g = root.to_graph(**kwargs)
if not abstract:
graph.__iadd__(g)
else:
for t in g.objects(root.node, RDF.type):
graph.add((root.node, RDF.type, t))
for e in self.__enrichments:
graph.add((node, CORE.implements, e.node))
if not abstract:
e.to_graph(graph=graph, node=e.node, td_nodes=td_nodes)
return graph
def __init__(self, uri=None, types=None):
# type: (any, iter) -> None
self.__graph = bound_graph(identifier=uri)
self.__node = uri
if self.__node is None:
self.__node = BNode()
if types is None:
types = []
self.__types = set(types)
for t in self.__types:
self.__graph.add((self.__node, RDF.type, URIRef(t)))
def to_graph(self, graph=None, node=None, **kwargs):
if node is None:
node = BNode()
if graph is None:
graph = bound_graph(str(node))
if (node, None, None) in graph:
return graph
graph.add((node, RDF.type, MAP.StringReplacement))
graph.add((node, MAP.match, Literal(self.match)))
graph.add((node, MAP['replace'], Literal(self.replace)))
return graph
def to_graph(self, graph=None, node=None, **kwargs):
if node is None:
node = BNode()
if graph is None:
graph = bound_graph(str(node))
if (node, None, None) in graph:
return graph
graph.add((node, RDF.type, MAP.SPARQLQuery))
graph.add((node, MAP.queryText, Literal(self.query)))
graph.add((node, MAP.sparqlHost, Literal(self.host)))
return graph
def to_graph(self, graph=None, node=None):
# type: (Graph, Node) -> Graph
if node is None:
node = self.node or BNode()
if graph is None:
graph = bound_graph(identifier=str(node))
if (node, None, None) in graph:
return graph
graph.add((node, RDF.type, WOT.Link))
if self.href:
graph.add((node, WOT.href, Literal(self.href)))
if self.whref:
graph.add((node, WOT.withHRef, Literal(self.whref)))
graph.add((node, WOT.mediaType, Literal(self.media)))
graph.add((node, CORE.identifier, Literal(self.id)))
return graph
def to_graph(self, graph=None, node=None, td_nodes=None, **kwargs):
if node is None:
node = self.node or BNode()
if graph is None:
graph = bound_graph(str(node))
eco_node = self.ecosystem.node
self.ecosystem.to_graph(graph=graph,
node=eco_node,
td_nodes=td_nodes,
**kwargs)
graph.add((node, RDF.type, CORE.ThingEcosystemDescription))
graph.add((node, CORE.describes, eco_node))
if td_nodes:
for td_node in td_nodes.values():
if isinstance(td_node, TD):
graph.add((node, CORE.usesTD, td_node))
return graph
def to_graph(self, graph=None, node=None, td_nodes=None):
# type: (Graph, Node, dict) -> Graph
if node is None:
node = self.node or BNode()
if graph is None:
graph = bound_graph(identifier=str(node))
if (node, None, None) in graph:
return graph
graph.add((node, RDF.type, MAP.Enrichment))
graph.add((node, CORE.identifier, Literal(self.id)))
graph.add((node, MAP.replacesValues, Literal(self.replace)))
if self.resource_type:
graph.add((node, MAP.instancesOf, URIRef(self.resource_type)))
if self.td:
td_node = td_nodes.get(self.td, None) if td_nodes else self.td.node
graph.add((node, MAP.resourcesEnrichedBy, URIRef(td_node)))
return graph
def to_graph(self, graph=None, node=None, td_nodes=None, **kwargs):
if node is None:
node = BNode()
if graph is None:
graph = bound_graph(identifier=str(node))
if (node, None, None) in graph:
return graph
graph.add((node, RDF.type, MAP.AccessMapping))
graph.add((node, CORE.identifier, Literal(self.id)))
if self.endpoint:
if td_nodes:
if self.endpoint not in td_nodes:
td_nodes[self.endpoint] = BNode()
e_node = td_nodes[self.endpoint]
else:
e_node = self.endpoint.node if self.endpoint else None
if e_node:
graph.add((node, MAP.mapsResourcesFrom, e_node))
if self.endpoint:
self.endpoint.to_graph(graph=graph, node=e_node)
for m in self.mappings:
if td_nodes:
if m not in td_nodes:
td_nodes[m] = BNode()
m_node = td_nodes[m]
else:
m_node = BNode()
m.to_graph(graph=graph, node=m_node, td_nodes=td_nodes, **kwargs)
graph.add((node, MAP.hasMapping, m_node))
if self.__order is not None:
graph.add((node, MAP.order, Literal(self.order)))
return graph
def to_graph(self, graph=None, node=None, td_nodes=None, **kwargs):
if node is None:
node = BNode()
if graph is None:
graph = bound_graph()
if (node, None, None) in graph:
return graph
graph.add((node, RDF.type, MAP.Mapping))
graph.add((node, CORE.identifier, Literal(self.id)))
graph.add((node, MAP.predicate, URIRef(self.predicate)))
graph.add((node, MAP.key, Literal(self.key)))
graph.add((node, MAP.rootMode, Literal(self.root)))
if self.path:
graph.add((node, MAP.jsonPath, Literal(self.path)))
if self.target_class:
graph.add((node, MAP.targetClass, URIRef(self.target_class)))
elif self.target_datatype:
graph.add((node, MAP.targetDatatype, URIRef(self.target_datatype)))
if self.transform:
if isinstance(self.transform, ResourceTransform):
transform_node = td_nodes.get(
self.transform.td,
None) if td_nodes else self.transform.td.node
elif isinstance(self.transform, URITransform):
transform_node = self.transform.uri
else:
transform_node = BNode()
self.transform.to_graph(graph=graph,
node=transform_node,
**kwargs)
if transform_node:
graph.add((node, MAP.valuesTransformedBy, transform_node))
return graph
def _resource_graph(uri, prefixes):
g = bound_graph(identifier=uri)
for prefix, uri in prefixes.items():
g.bind(prefix, uri)
return g
def to_graph(self,
graph=None,
node=None,
td_nodes=None,
th_nodes=None,
abstract=False,
**kwargs):
# type: (Graph, Node, dict, dict, bool, dict) -> Graph
if td_nodes is None:
td_nodes = {}
if node is None:
node = td_nodes.get(self, None) or self.node or BNode()
if graph is None:
graph = bound_graph(str(node))
if (node, None, None) in graph:
return graph
resource_node = self.resource.node
if th_nodes:
resource_node = th_nodes.get(resource_node, resource_node)
graph.add((node, RDF.type, CORE.ThingDescription))
graph.add((node, CORE.describes, resource_node))
graph.add((node, CORE.identifier, Literal(self.id)))
for ext in self.extends:
graph.add((node, CORE.extends, td_nodes.get(ext, ext.node)))
if not abstract:
for am in self.__access_mappings:
if td_nodes:
if am not in td_nodes:
td_nodes[am] = BNode()
am_node = td_nodes[am]
else:
am_node = BNode()
graph.add((node, MAP.hasAccessMapping, am_node))
am.to_graph(graph=graph,
node=am_node,
td_nodes=td_nodes,
**kwargs)
for rdfs in self.rdf_sources:
if td_nodes:
if rdfs not in td_nodes:
td_nodes[rdfs] = BNode()
r_node = td_nodes[rdfs]
else:
r_node = BNode()
graph.add((node, MAP.fromRDFSource, r_node))
rdfs.to_graph(graph=graph, node=r_node)
r_node = self.resource.node
if not (th_nodes is None or r_node in th_nodes):
r_graph = self.resource.to_graph(**kwargs)
for s, p, o in r_graph:
ss = th_nodes.get(s, s) if th_nodes else s
oo = th_nodes.get(o, o) if th_nodes else o
graph.add((ss, p, oo))
return graph
def prefixed_graph(gw):
g = bound_graph()
for prefix, uri in gw.agora.fountain.prefixes.items():
g.bind(prefix, uri)
return g