def write_ship_coordinates_file(ship_iri, coordinates, graph,
file_destination):
(x_coordinate, y_coordinate) = coordinates # (lon, lat)
query_string = """
PREFIX j1: <http://www.theworldavatar.com/ontology/ontocape/upper_level/system.owl#>
PREFIX j4: <http://www.theworldavatar.com/ontology/ontocape/supporting_concepts/space_and_time/space_and_time_extended.owl#>
DELETE {{
?coordinateX_V j1:numericalValue ?coordinateX_value .
?coordinateY_V j1:numericalValue ?coordinateY_value .
}}
INSERT
{{
?coordinateX_V j1:numericalValue {1}.
?coordinateY_V j1:numericalValue {2} .
}}
WHERE
{{
<{0}> j4:hasGISCoordinateSystem ?coordinateSystem .
?coordinateSystem j4:hasProjectedCoordinate_x ?coordinateX .
?coordinateX j1:hasValue ?coordinateX_V .
?coordinateX_V j1:numericalValue ?coordinateX_value .
?coordinateSystem j4:hasProjectedCoordinate_y ?coordinateY .
?coordinateY j1:hasValue ?coordinateY_V .
?coordinateY_V j1:numericalValue ?coordinateY_value .
}}
""".format(ship_iri, x_coordinate, y_coordinate)
processUpdate(graph, query_string)
graph.serialize(destination=file_destination, format='xml')
def run_sql(self, query, type, return_type):
'''
Args:
query (str): sparql query
type (str): insert/query type
Returns:
dict.: query result
Raises:
Exceptions on error
'''
# set return
ret_type = 'application/sparql-results+json'
# query
if type == "insert":
# we call this to update, either returns for success
# or throws an exception (try block in calling code)
processUpdate(self.g, query)
ret = json.dumps({"status": "success"})
else:
# run query for SELECT, ASK or now CONSTRUCT
if 'DESCRIBE' in query:
# get object
actual_query = query.split('<', 1)[1].split('>')[0]
print("describe", actual_query)
node_graph = self.get_graph_with_node(URIRef(actual_query))
ret_type = 'text/turtle'
# return info
return node_graph.serialize(format="turtle",
base=self.my_host_name), ret_type
# run query
result = self.g.query(query)
# check if CONSTRUCT as this returns a graph
if result.type == 'CONSTRUCT':
# test type
if 'text/turtle' in return_type:
ret_type = 'text/turtle'
# convert graph to turtle
ret = result.serialize(format="turtle",
base=self.my_host_name)
else:
# convert graph to JSON
ret = self.graph_to_json(result.graph)
else:
# convert to JSON
ret = result.serialize(format="json")
# print("json",ret)
# return
return ret, ret_type
def testCycleDetection():
qMakeCycle = '''
PREFIX prov: <http://www.w3.org/ns/prov#>
PREFIX c: <http://www.few.vu.nl/pgroth/provconstraints#>
INSERT DATA {
c:start c:precedes c:two .
c:two c:precedes c:three .
c:three c:strictlyPrecedes c:start .
}
'''
g = rdflib.Graph()
processUpdate(g, qMakeCycle)
print(g.serialize(format='turtle'))
print(checkCycle(g))
def do_insert(self, resource_count: int) -> None:
EGV = Namespace("http://example.org/vocab#")
EGI = Namespace("http://example.org/instance#")
prop0, prop1, prop2 = EGV["prop0"], EGV["prop1"], EGV["prop2"]
g0 = Graph()
for index in range(resource_count):
resource = EGI[f"resource{index}"]
g0.add((resource, prop0, Literal(index)))
g0.add((resource, prop1, Literal("example resource")))
g0.add((resource, prop2, Literal(f"resource #{index}")))
g0ntriples = g0.serialize(format="ntriples")
g1 = Graph()
self.assertNotEqual(triple_set(g0), triple_set(g1))
processUpdate(g1, f"INSERT DATA {{ {g0ntriples!s} }}")
self.assertEqual(triple_set(g0), triple_set(g1))
def orderingConstraints(g):
processUpdate(g, start_precedes_end)
processUpdate(g, start_start_ordering)
processUpdate(g, end_end_ordering)
processUpdate(g, usage_within_activity1)
processUpdate(g, usage_within_activity2)
processUpdate(g, generation_within_activity1)
processUpdate(g, generation_within_activity2)
processUpdate(g, wasInformedBy_ordering)
processUpdate(g, generation_precedes_invalidation)
processUpdate(g, generation_precedes_usage)
processUpdate(g, usage_precedes_invalidation)
processUpdate(g, generation_generation_ordering)
processUpdate(g, invalidation_invalidation_ordering)
processUpdate(g, derivation_usage_generation_ordering)
processUpdate(g, derivation_generation_generation_ordering)
processUpdate(g, wasStartedBy_ordering1)
processUpdate(g, wasStartedBy_ordering2)
processUpdate(g, wasEndedBy_ordering1)
processUpdate(g, wasEndedBy_ordering2)
processUpdate(g, specialization_generation_ordering)
processUpdate(g, specialization_invalidation_ordering)
processUpdate(g, wasAssociatedWith_ordering1)
processUpdate(g, wasAssociatedWith_ordering2)
processUpdate(g, wasAssociatedWith_ordering3)
processUpdate(g, wasAssociatedWith_ordering4)
processUpdate(g, wasAttributedTo_ordering1)
processUpdate(g, wasAttributedTo_ordering2)
processUpdate(g, actedOnBehalfOf_ordering1)
processUpdate(g, actedOnBehalfOf_ordering2)
return g
def testCycleDetection():
g = rdflib.Graph()
processUpdate(g, qMakeCycle)
print(g.serialize(format='turtle'))
print(checkCycle(g))
