Mercurial > repos > shellac > sam_consensus_v3
comparison env/lib/python3.9/site-packages/prov/serializers/provrdf.py @ 0:4f3585e2f14b draft default tip
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author | shellac |
---|---|
date | Mon, 22 Mar 2021 18:12:50 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:4f3585e2f14b |
---|---|
1 """PROV-RDF serializers for ProvDocument | |
2 """ | |
3 from __future__ import (absolute_import, division, print_function, | |
4 unicode_literals) | |
5 | |
6 import base64 | |
7 from collections import OrderedDict | |
8 import datetime | |
9 import io | |
10 | |
11 import dateutil.parser | |
12 import six | |
13 | |
14 from rdflib.term import URIRef, BNode | |
15 from rdflib.term import Literal as RDFLiteral | |
16 from rdflib.graph import ConjunctiveGraph | |
17 from rdflib.namespace import RDF, RDFS, XSD | |
18 | |
19 import prov.model as pm | |
20 from prov.constants import ( | |
21 PROV, PROV_ID_ATTRIBUTES_MAP, PROV_N_MAP, PROV_BASE_CLS, XSD_QNAME, | |
22 PROV_END, PROV_START, PROV_USAGE, PROV_GENERATION, PROV_DERIVATION, PROV_INVALIDATION, | |
23 PROV_ALTERNATE, PROV_MENTION, PROV_DELEGATION, PROV_ACTIVITY, PROV_ATTR_STARTTIME, | |
24 PROV_ATTR_ENDTIME, PROV_LOCATION, PROV_ATTR_TIME, PROV_ROLE, PROV_COMMUNICATION, | |
25 PROV_ATTR_INFORMANT, PROV_ATTR_RESPONSIBLE, PROV_ATTR_TRIGGER, PROV_ATTR_ENDER, | |
26 PROV_ATTR_STARTER, PROV_ATTR_USED_ENTITY) | |
27 from prov.serializers import Serializer, Error | |
28 | |
29 | |
30 __author__ = 'Satrajit S. Ghosh' | |
31 __email__ = 'satra@mit.edu' | |
32 | |
33 | |
34 class ProvRDFException(Error): | |
35 pass | |
36 | |
37 | |
38 class AnonymousIDGenerator: | |
39 def __init__(self): | |
40 self._cache = {} | |
41 self._count = 0 | |
42 | |
43 def get_anon_id(self, obj, local_prefix="id"): | |
44 if obj not in self._cache: | |
45 self._count += 1 | |
46 self._cache[obj] = pm.Identifier( | |
47 '_:%s%d' % (local_prefix, self._count) | |
48 ).uri | |
49 return self._cache[obj] | |
50 | |
51 | |
52 # Reverse map for prov.model.XSD_DATATYPE_PARSERS | |
53 LITERAL_XSDTYPE_MAP = { | |
54 float: XSD['double'], | |
55 int: XSD['int'], | |
56 six.text_type: XSD['string'], | |
57 # boolean, string values are supported natively by PROV-RDF | |
58 # datetime values are converted separately | |
59 } | |
60 | |
61 # Add long on Python 2 | |
62 if six.integer_types[-1] not in LITERAL_XSDTYPE_MAP: | |
63 LITERAL_XSDTYPE_MAP[six.integer_types[-1]] = XSD['long'] | |
64 | |
65 | |
66 def attr2rdf(attr): | |
67 return URIRef(PROV[PROV_ID_ATTRIBUTES_MAP[attr].split('prov:')[1]].uri) | |
68 | |
69 | |
70 def valid_qualified_name(bundle, value, xsd_qname=False): | |
71 if value is None: | |
72 return None | |
73 qualified_name = bundle.valid_qualified_name(value) | |
74 return qualified_name if not xsd_qname else XSD_QNAME(qualified_name) | |
75 | |
76 | |
77 class ProvRDFSerializer(Serializer): | |
78 """ | |
79 PROV-O serializer for :class:`~prov.model.ProvDocument` | |
80 """ | |
81 | |
82 def serialize(self, stream=None, rdf_format='trig', **kwargs): | |
83 """ | |
84 Serializes a :class:`~prov.model.ProvDocument` instance to | |
85 `PROV-O <https://www.w3.org/TR/prov-o/>`_. | |
86 | |
87 :param stream: Where to save the output. | |
88 :param rdf_format: The RDF format of the output, default to TRiG. | |
89 """ | |
90 container = self.encode_document(self.document) | |
91 newargs = kwargs.copy() | |
92 newargs['format'] = rdf_format | |
93 | |
94 if six.PY2: | |
95 buf = io.BytesIO() | |
96 try: | |
97 container.serialize(buf, **newargs) | |
98 buf.seek(0, 0) | |
99 # Right now this is a bytestream. If the object to stream to is | |
100 # a text object is must be decoded. We assume utf-8 here which | |
101 # should be fine for almost every case. | |
102 if isinstance(stream, io.TextIOBase): | |
103 stream.write(buf.read().decode('utf-8')) | |
104 else: | |
105 stream.write(buf.read()) | |
106 finally: | |
107 buf.close() | |
108 else: | |
109 buf = io.BytesIO() | |
110 try: | |
111 container.serialize(buf, **newargs) | |
112 buf.seek(0, 0) | |
113 # Right now this is a bytestream. If the object to stream to is | |
114 # a text object is must be decoded. We assume utf-8 here which | |
115 # should be fine for almost every case. | |
116 if isinstance(stream, io.TextIOBase): | |
117 stream.write(buf.read().decode('utf-8')) | |
118 else: | |
119 stream.write(buf.read()) | |
120 finally: | |
121 buf.close() | |
122 | |
123 def deserialize(self, stream, rdf_format='trig', **kwargs): | |
124 """ | |
125 Deserialize from the `PROV-O <https://www.w3.org/TR/prov-o/>`_ | |
126 representation to a :class:`~prov.model.ProvDocument` instance. | |
127 | |
128 :param stream: Input data. | |
129 :param rdf_format: The RDF format of the input data, default: TRiG. | |
130 """ | |
131 newargs = kwargs.copy() | |
132 newargs['format'] = rdf_format | |
133 container = ConjunctiveGraph() | |
134 container.parse(stream, **newargs) | |
135 document = pm.ProvDocument() | |
136 self.document = document | |
137 self.decode_document(container, document) | |
138 return document | |
139 | |
140 def valid_identifier(self, value): | |
141 return self.document.valid_qualified_name(value) | |
142 | |
143 def encode_rdf_representation(self, value): | |
144 if isinstance(value, URIRef): | |
145 return value | |
146 elif isinstance(value, pm.Literal): | |
147 return literal_rdf_representation(value) | |
148 elif isinstance(value, datetime.datetime): | |
149 return RDFLiteral(value.isoformat(), datatype=XSD['dateTime']) | |
150 elif isinstance(value, pm.QualifiedName): | |
151 return URIRef(value.uri) | |
152 elif isinstance(value, pm.Identifier): | |
153 return RDFLiteral(value.uri, datatype=XSD['anyURI']) | |
154 elif type(value) in LITERAL_XSDTYPE_MAP: | |
155 return RDFLiteral(value, datatype=LITERAL_XSDTYPE_MAP[type(value)]) | |
156 else: | |
157 return RDFLiteral(value) | |
158 | |
159 def decode_rdf_representation(self, literal, graph): | |
160 if isinstance(literal, RDFLiteral): | |
161 value = literal.value if literal.value is not None else literal | |
162 datatype = literal.datatype if hasattr(literal, 'datatype') else None | |
163 langtag = literal.language if hasattr(literal, 'language') else None | |
164 if datatype and 'XMLLiteral' in datatype: | |
165 value = literal | |
166 if datatype and 'base64Binary' in datatype: | |
167 value = base64.standard_b64encode(value) | |
168 if datatype == XSD['QName']: | |
169 return pm.Literal(literal, datatype=XSD_QNAME) | |
170 if datatype == XSD['dateTime']: | |
171 return dateutil.parser.parse(literal) | |
172 if datatype == XSD['gYear']: | |
173 return pm.Literal(dateutil.parser.parse(literal).year, | |
174 datatype=self.valid_identifier(datatype)) | |
175 if datatype == XSD['gYearMonth']: | |
176 parsed_info = dateutil.parser.parse(literal) | |
177 return pm.Literal('{0}-{1:02d}'.format(parsed_info.year, parsed_info.month), | |
178 datatype=self.valid_identifier(datatype)) | |
179 else: | |
180 # The literal of standard Python types is not converted here | |
181 # It will be automatically converted when added to a record by | |
182 # _auto_literal_conversion() | |
183 return pm.Literal(value, self.valid_identifier(datatype), langtag) | |
184 elif isinstance(literal, URIRef): | |
185 rval = self.valid_identifier(literal) | |
186 if rval is None: | |
187 prefix, iri, _ = graph.namespace_manager.compute_qname(literal) | |
188 ns = self.document.add_namespace(prefix, iri) | |
189 rval = pm.QualifiedName(ns, literal.replace(ns.uri, '')) | |
190 return rval | |
191 else: | |
192 # simple type, just return it | |
193 return literal | |
194 | |
195 def encode_document(self, document): | |
196 container = self.encode_container(document) | |
197 for item in document.bundles: | |
198 # encoding the sub-bundle | |
199 bundle = self.encode_container(item, identifier=item.identifier.uri) | |
200 container.addN(bundle.quads()) | |
201 return container | |
202 | |
203 def encode_container(self, bundle, container=None, identifier=None): | |
204 if container is None: | |
205 container = ConjunctiveGraph(identifier=identifier) | |
206 nm = container.namespace_manager | |
207 nm.bind('prov', PROV.uri) | |
208 | |
209 for namespace in bundle.namespaces: | |
210 container.bind(namespace.prefix, namespace.uri) | |
211 | |
212 id_generator = AnonymousIDGenerator() | |
213 real_or_anon_id = lambda record: record._identifier.uri if \ | |
214 record._identifier else id_generator.get_anon_id(record) | |
215 | |
216 for record in bundle._records: | |
217 rec_type = record.get_type() | |
218 if hasattr(record, 'identifier') and record.identifier: | |
219 identifier = URIRef(six.text_type(real_or_anon_id(record))) | |
220 container.add((identifier, RDF.type, URIRef(rec_type.uri))) | |
221 else: | |
222 identifier = None | |
223 if record.attributes: | |
224 bnode = None | |
225 formal_objects = [] | |
226 used_objects = [] | |
227 all_attributes = list(record.formal_attributes) + list(record.attributes) | |
228 formal_qualifiers = False | |
229 for attrid, (attr, value) in enumerate(list(record.formal_attributes)): | |
230 if (identifier is not None and value is not None) or \ | |
231 (identifier is None and value is not None and attrid > 1): | |
232 formal_qualifiers = True | |
233 has_qualifiers = len(record.extra_attributes) > 0 or formal_qualifiers | |
234 for idx, (attr, value) in enumerate(all_attributes): | |
235 if record.is_relation(): | |
236 pred = URIRef(PROV[PROV_N_MAP[rec_type]].uri) | |
237 # create bnode relation | |
238 if bnode is None: | |
239 valid_formal_indices = set() | |
240 for idx, (key, val) in enumerate(record.formal_attributes): | |
241 formal_objects.append(key) | |
242 if val: | |
243 valid_formal_indices.add(idx) | |
244 used_objects = [record.formal_attributes[0][0]] | |
245 subj = None | |
246 if record.formal_attributes[0][1]: | |
247 subj = URIRef(record.formal_attributes[0][1].uri) | |
248 if identifier is None and subj is not None: | |
249 try: | |
250 obj_val = record.formal_attributes[1][1] | |
251 obj_attr = URIRef(record.formal_attributes[1][0].uri) | |
252 # TODO: Why is obj_attr above not used anywhere? | |
253 except IndexError: | |
254 obj_val = None | |
255 if obj_val and (rec_type not in {PROV_END, | |
256 PROV_START, | |
257 PROV_USAGE, | |
258 PROV_GENERATION, | |
259 PROV_DERIVATION, | |
260 PROV_INVALIDATION} or | |
261 (valid_formal_indices == {0, 1} and | |
262 len(record.extra_attributes) == 0)): | |
263 used_objects.append(record.formal_attributes[1][0]) | |
264 obj_val = self.encode_rdf_representation(obj_val) | |
265 if rec_type == PROV_ALTERNATE: | |
266 subj, obj_val = obj_val, subj | |
267 container.add((subj, pred, obj_val)) | |
268 if rec_type == PROV_MENTION: | |
269 if record.formal_attributes[2][1]: | |
270 used_objects.append(record.formal_attributes[2][0]) | |
271 obj_val = self.encode_rdf_representation(record.formal_attributes[2][1]) | |
272 container.add((subj, URIRef(PROV['asInBundle'].uri), obj_val)) | |
273 has_qualifiers = False | |
274 if rec_type in [PROV_ALTERNATE]: | |
275 continue | |
276 if subj and (has_qualifiers or identifier): | |
277 qualifier = rec_type._localpart | |
278 rec_uri = rec_type.uri | |
279 for attr_name, val in record.extra_attributes: | |
280 if attr_name == PROV['type']: | |
281 if PROV['Revision'] == val or \ | |
282 PROV['Quotation'] == val or \ | |
283 PROV['PrimarySource'] == val: | |
284 qualifier = val._localpart | |
285 rec_uri = val.uri | |
286 if identifier is not None: | |
287 container.remove((identifier, | |
288 RDF.type, | |
289 URIRef(rec_type.uri))) | |
290 QRole = URIRef(PROV['qualified' + qualifier].uri) | |
291 if identifier is not None: | |
292 container.add((subj, QRole, identifier)) | |
293 else: | |
294 bnode = identifier = BNode() | |
295 container.add((subj, QRole, identifier)) | |
296 container.add( | |
297 (identifier, RDF.type, URIRef(rec_uri)) | |
298 ) # reset identifier to BNode | |
299 if value is not None and attr not in used_objects: | |
300 if attr in formal_objects: | |
301 pred = attr2rdf(attr) | |
302 elif attr == PROV['role']: | |
303 pred = URIRef(PROV['hadRole'].uri) | |
304 elif attr == PROV['plan']: | |
305 pred = URIRef(PROV['hadPlan'].uri) | |
306 elif attr == PROV['type']: | |
307 pred = RDF.type | |
308 elif attr == PROV['label']: | |
309 pred = RDFS.label | |
310 elif isinstance(attr, pm.QualifiedName): | |
311 pred = URIRef(attr.uri) | |
312 else: | |
313 pred = self.encode_rdf_representation(attr) | |
314 if PROV['plan'].uri in pred: | |
315 pred = URIRef(PROV['hadPlan'].uri) | |
316 if PROV['informant'].uri in pred: | |
317 pred = URIRef(PROV['activity'].uri) | |
318 if PROV['responsible'].uri in pred: | |
319 pred = URIRef(PROV['agent'].uri) | |
320 if rec_type == PROV_DELEGATION and PROV['activity'].uri in pred: | |
321 pred = URIRef(PROV['hadActivity'].uri) | |
322 if (rec_type in [PROV_END, PROV_START] and PROV['trigger'].uri in pred) or\ | |
323 (rec_type in [PROV_USAGE] and PROV['used'].uri in pred): | |
324 pred = URIRef(PROV['entity'].uri) | |
325 if rec_type in [PROV_GENERATION, PROV_END, | |
326 PROV_START, PROV_USAGE, | |
327 PROV_INVALIDATION]: | |
328 if PROV['time'].uri in pred: | |
329 pred = URIRef(PROV['atTime'].uri) | |
330 if PROV['ender'].uri in pred: | |
331 pred = URIRef(PROV['hadActivity'].uri) | |
332 if PROV['starter'].uri in pred: | |
333 pred = URIRef(PROV['hadActivity'].uri) | |
334 if PROV['location'].uri in pred: | |
335 pred = URIRef(PROV['atLocation'].uri) | |
336 if rec_type in [PROV_ACTIVITY]: | |
337 if PROV_ATTR_STARTTIME in pred: | |
338 pred = URIRef(PROV['startedAtTime'].uri) | |
339 if PROV_ATTR_ENDTIME in pred: | |
340 pred = URIRef(PROV['endedAtTime'].uri) | |
341 if rec_type == PROV_DERIVATION: | |
342 if PROV['activity'].uri in pred: | |
343 pred = URIRef(PROV['hadActivity'].uri) | |
344 if PROV['generation'].uri in pred: | |
345 pred = URIRef(PROV['hadGeneration'].uri) | |
346 if PROV['usage'].uri in pred: | |
347 pred = URIRef(PROV['hadUsage'].uri) | |
348 if PROV['usedEntity'].uri in pred: | |
349 pred = URIRef(PROV['entity'].uri) | |
350 container.add((identifier, pred, | |
351 self.encode_rdf_representation(value))) | |
352 continue | |
353 if value is None: | |
354 continue | |
355 if isinstance(value, pm.ProvRecord): | |
356 obj = URIRef(six.text_type(real_or_anon_id(value))) | |
357 else: | |
358 # Assuming this is a datetime value | |
359 obj = self.encode_rdf_representation(value) | |
360 if attr == PROV['location']: | |
361 pred = URIRef(PROV['atLocation'].uri) | |
362 if False and isinstance(value, (URIRef, pm.QualifiedName)): | |
363 if isinstance(value, pm.QualifiedName): | |
364 value = URIRef(value.uri) | |
365 container.add((identifier, pred, value)) | |
366 else: | |
367 container.add((identifier, pred, | |
368 self.encode_rdf_representation(obj))) | |
369 continue | |
370 if attr == PROV['type']: | |
371 pred = RDF.type | |
372 elif attr == PROV['label']: | |
373 pred = RDFS.label | |
374 elif attr == PROV_ATTR_STARTTIME: | |
375 pred = URIRef(PROV['startedAtTime'].uri) | |
376 elif attr == PROV_ATTR_ENDTIME: | |
377 pred = URIRef(PROV['endedAtTime'].uri) | |
378 else: | |
379 pred = self.encode_rdf_representation(attr) | |
380 container.add((identifier, pred, obj)) | |
381 return container | |
382 | |
383 def decode_document(self, content, document): | |
384 for prefix, url in content.namespaces(): | |
385 document.add_namespace(prefix, six.text_type(url)) | |
386 if hasattr(content, 'contexts'): | |
387 for graph in content.contexts(): | |
388 if isinstance(graph.identifier, BNode): | |
389 self.decode_container(graph, document) | |
390 else: | |
391 bundle_id = six.text_type(graph.identifier) | |
392 bundle = document.bundle(bundle_id) | |
393 self.decode_container(graph, bundle) | |
394 else: | |
395 self.decode_container(content, document) | |
396 | |
397 def decode_container(self, graph, bundle): | |
398 ids = {} | |
399 PROV_CLS_MAP = {} | |
400 formal_attributes = {} | |
401 unique_sets = {} | |
402 for key, val in PROV_BASE_CLS.items(): | |
403 PROV_CLS_MAP[key.uri] = PROV_BASE_CLS[key] | |
404 relation_mapper = {URIRef(PROV['alternateOf'].uri): 'alternate', | |
405 URIRef(PROV['actedOnBehalfOf'].uri): 'delegation', | |
406 URIRef(PROV['specializationOf'].uri): 'specialization', | |
407 URIRef(PROV['mentionOf'].uri): 'mention', | |
408 URIRef(PROV['wasAssociatedWith'].uri): 'association', | |
409 URIRef(PROV['wasDerivedFrom'].uri): 'derivation', | |
410 URIRef(PROV['wasAttributedTo'].uri): 'attribution', | |
411 URIRef(PROV['wasInformedBy'].uri): 'communication', | |
412 URIRef(PROV['wasGeneratedBy'].uri): 'generation', | |
413 URIRef(PROV['wasInfluencedBy'].uri): 'influence', | |
414 URIRef(PROV['wasInvalidatedBy'].uri): 'invalidation', | |
415 URIRef(PROV['wasEndedBy'].uri): 'end', | |
416 URIRef(PROV['wasStartedBy'].uri): 'start', | |
417 URIRef(PROV['hadMember'].uri): 'membership', | |
418 URIRef(PROV['used'].uri): 'usage', | |
419 } | |
420 predicate_mapper = {RDFS.label: pm.PROV['label'], | |
421 URIRef(PROV['atLocation'].uri): PROV_LOCATION, | |
422 URIRef(PROV['startedAtTime'].uri): PROV_ATTR_STARTTIME, | |
423 URIRef(PROV['endedAtTime'].uri): PROV_ATTR_ENDTIME, | |
424 URIRef(PROV['atTime'].uri): PROV_ATTR_TIME, | |
425 URIRef(PROV['hadRole'].uri): PROV_ROLE, | |
426 URIRef(PROV['hadPlan'].uri): pm.PROV_ATTR_PLAN, | |
427 URIRef(PROV['hadUsage'].uri): pm.PROV_ATTR_USAGE, | |
428 URIRef(PROV['hadGeneration'].uri): pm.PROV_ATTR_GENERATION, | |
429 URIRef(PROV['hadActivity'].uri): pm.PROV_ATTR_ACTIVITY, | |
430 } | |
431 other_attributes = {} | |
432 for stmt in graph.triples((None, RDF.type, None)): | |
433 id = six.text_type(stmt[0]) | |
434 obj = six.text_type(stmt[2]) | |
435 if obj in PROV_CLS_MAP: | |
436 if not isinstance(stmt[0], BNode) and self.valid_identifier(id) is None: | |
437 prefix, iri, _ = graph.namespace_manager.compute_qname(id) | |
438 self.document.add_namespace(prefix, iri) | |
439 try: | |
440 prov_obj = PROV_CLS_MAP[obj] | |
441 except AttributeError: | |
442 prov_obj = None | |
443 add_attr = True | |
444 isderivation = pm.PROV['Revision'].uri in stmt[2] or \ | |
445 pm.PROV['Quotation'].uri in stmt[2] or \ | |
446 pm.PROV['PrimarySource'].uri in stmt[2] | |
447 if id not in ids and prov_obj and (prov_obj.uri == obj or | |
448 isderivation or | |
449 isinstance(stmt[0], BNode)): | |
450 ids[id] = prov_obj | |
451 klass = pm.PROV_REC_CLS[prov_obj] | |
452 formal_attributes[id] = OrderedDict([(key, None) for key in klass.FORMAL_ATTRIBUTES]) | |
453 unique_sets[id] = OrderedDict([(key, []) for key in klass.FORMAL_ATTRIBUTES]) | |
454 add_attr = False or ((isinstance(stmt[0], BNode) or isderivation) and prov_obj.uri != obj) | |
455 if add_attr: | |
456 if id not in other_attributes: | |
457 other_attributes[id] = [] | |
458 obj_formatted = self.decode_rdf_representation(stmt[2], graph) | |
459 other_attributes[id].append((pm.PROV['type'], obj_formatted)) | |
460 else: | |
461 if id not in other_attributes: | |
462 other_attributes[id] = [] | |
463 obj = self.decode_rdf_representation(stmt[2], graph) | |
464 other_attributes[id].append((pm.PROV['type'], obj)) | |
465 for id, pred, obj in graph: | |
466 id = six.text_type(id) | |
467 if id not in other_attributes: | |
468 other_attributes[id] = [] | |
469 if pred == RDF.type: | |
470 continue | |
471 if pred in relation_mapper: | |
472 if 'alternateOf' in pred: | |
473 getattr(bundle, relation_mapper[pred])(obj, id) | |
474 elif 'mentionOf' in pred: | |
475 mentionBundle = None | |
476 for stmt in graph.triples((URIRef(id), URIRef(pm.PROV['asInBundle'].uri), None)): | |
477 mentionBundle = stmt[2] | |
478 getattr(bundle, relation_mapper[pred])(id, six.text_type(obj), mentionBundle) | |
479 elif 'actedOnBehalfOf' in pred or 'wasAssociatedWith' in pred: | |
480 qualifier = 'qualified' + relation_mapper[pred].upper()[0] + relation_mapper[pred][1:] | |
481 qualifier_bnode = None | |
482 for stmt in graph.triples((URIRef(id), URIRef(pm.PROV[qualifier].uri), None)): | |
483 qualifier_bnode = stmt[2] | |
484 if qualifier_bnode is None: | |
485 getattr(bundle, relation_mapper[pred])(id, six.text_type(obj)) | |
486 else: | |
487 fakeys = list(formal_attributes[six.text_type(qualifier_bnode)].keys()) | |
488 formal_attributes[six.text_type(qualifier_bnode)][fakeys[0]] = id | |
489 formal_attributes[six.text_type(qualifier_bnode)][fakeys[1]] = six.text_type(obj) | |
490 else: | |
491 getattr(bundle, relation_mapper[pred])(id, six.text_type(obj)) | |
492 elif id in ids: | |
493 obj1 = self.decode_rdf_representation(obj, graph) | |
494 if obj is not None and obj1 is None: | |
495 raise ValueError(('Error transforming', obj)) | |
496 pred_new = pred | |
497 if pred in predicate_mapper: | |
498 pred_new = predicate_mapper[pred] | |
499 if ids[id] == PROV_COMMUNICATION and 'activity' in six.text_type(pred_new): | |
500 pred_new = PROV_ATTR_INFORMANT | |
501 if ids[id] == PROV_DELEGATION and 'agent' in six.text_type(pred_new): | |
502 pred_new = PROV_ATTR_RESPONSIBLE | |
503 if ids[id] in [PROV_END, PROV_START] and 'entity' in six.text_type(pred_new): | |
504 pred_new = PROV_ATTR_TRIGGER | |
505 if ids[id] in [PROV_END] and 'activity' in six.text_type(pred_new): | |
506 pred_new = PROV_ATTR_ENDER | |
507 if ids[id] in [PROV_START] and 'activity' in six.text_type(pred_new): | |
508 pred_new = PROV_ATTR_STARTER | |
509 if ids[id] == PROV_DERIVATION and 'entity' in six.text_type(pred_new): | |
510 pred_new = PROV_ATTR_USED_ENTITY | |
511 if six.text_type(pred_new) in [val.uri for val in formal_attributes[id]]: | |
512 qname_key = self.valid_identifier(pred_new) | |
513 formal_attributes[id][qname_key] = obj1 | |
514 unique_sets[id][qname_key].append(obj1) | |
515 if len(unique_sets[id][qname_key]) > 1: | |
516 formal_attributes[id][qname_key] = None | |
517 else: | |
518 if 'qualified' not in six.text_type(pred_new) and \ | |
519 'asInBundle' not in six.text_type(pred_new): | |
520 other_attributes[id].append((six.text_type(pred_new), obj1)) | |
521 local_key = six.text_type(obj) | |
522 if local_key in ids: | |
523 if 'qualified' in pred: | |
524 formal_attributes[local_key][list(formal_attributes[local_key].keys())[0]] = id | |
525 for id in ids: | |
526 attrs = None | |
527 if id in other_attributes: | |
528 attrs = other_attributes[id] | |
529 items_to_walk = [] | |
530 for qname, values in unique_sets[id].items(): | |
531 if values and len(values) > 1: | |
532 items_to_walk.append((qname, values)) | |
533 if items_to_walk: | |
534 for subset in list(walk(items_to_walk)): | |
535 for key, value in subset.items(): | |
536 formal_attributes[id][key] = value | |
537 bundle.new_record(ids[id], id, formal_attributes[id], attrs) | |
538 else: | |
539 bundle.new_record(ids[id], id, formal_attributes[id], attrs) | |
540 ids[id] = None | |
541 if attrs is not None: | |
542 other_attributes[id] = [] | |
543 for key, val in other_attributes.items(): | |
544 if val: | |
545 ids[key].add_attributes(val) | |
546 | |
547 | |
548 def walk(children, level=0, path=None, usename=True): | |
549 """Generate all the full paths in a tree, as a dict. | |
550 | |
551 :Example: | |
552 | |
553 >>> from prov.serializers.provrdf import walk | |
554 >>> iterables = [('a', lambda: [1, 2]), ('b', lambda: [3, 4])] | |
555 >>> [val['a'] for val in walk(iterables)] | |
556 [1, 1, 2, 2] | |
557 >>> [val['b'] for val in walk(iterables)] | |
558 [3, 4, 3, 4] | |
559 """ | |
560 # Entry point | |
561 if level == 0: | |
562 path = {} | |
563 # Exit condition | |
564 if not children: | |
565 yield path.copy() | |
566 return | |
567 # Tree recursion | |
568 head, tail = children[0], children[1:] | |
569 name, func = head | |
570 for child in func: | |
571 # We can use the arg name or the tree level as a key | |
572 if usename: | |
573 path[name] = child | |
574 else: | |
575 path[level] = child | |
576 # Recurse into the next level | |
577 for child_paths in walk(tail, level + 1, path, usename): | |
578 yield child_paths | |
579 | |
580 | |
581 def literal_rdf_representation(literal): | |
582 value = six.text_type(literal.value) if literal.value else literal | |
583 if literal.langtag: | |
584 # a language tag can only go with prov:InternationalizedString | |
585 return RDFLiteral(value, lang=str(literal.langtag)) | |
586 else: | |
587 datatype = literal.datatype | |
588 if 'base64Binary' in datatype.uri: | |
589 if six.PY2: | |
590 value = base64.standard_b64encode(value) | |
591 else: | |
592 value = literal.value.encode() | |
593 return RDFLiteral(value, datatype=datatype.uri) |