def _property(col_name, atdm_row, atdm_table, column_metadata):
if 'propertyUrl' in column_metadata:
resolved = UriTemplateUtils.insert_value(
column_metadata['propertyUrl'], atdm_row, col_name,
atdm_table['url'])
return Namespaces.replace_url_with_prefix(resolved)
else:
return column_metadata['name']
def create_uri_ref(value, value_url):
if CommonProperties.is_common_property(value_url):
return Namespaces.get_term(value_url)
if '{' not in value_url:
return URIRef(value_url)
sufix = ''
key = value_url[value_url.find('{') + 1:value_url.find('}')]
domain = value_url[:value_url.find('{')]
if key.startswith('#'):
sufix = '#'
return URIRef(domain + sufix + value)
def _handle_list(entry, subject, language):
key, values = entry
predicate = Namespaces.get_term(key)
triples = []
for value in values:
if type(value) is dict:
triples.extend(
CommonProperties.property_to_triples((key, value), subject,
language))
else:
triples.append(
(subject, predicate, Literal(value, lang=language)))
return triples
def _handle_dict(entry, subject, language):
triples = []
key, json = entry
predicate = Namespaces.get_term(key)
if '@value' in json or '@id' in json:
raw_type = json.get('@type')
rdf_datatype = Namespaces.get_term(raw_type)
value = CommonProperties._json_ld_value(json, rdf_datatype)
triples.append((subject, predicate, value))
else:
local_subject = BNode()
triples.append((subject, predicate, local_subject))
for _key, _value in json.items():
if CommonProperties.is_common_property(_key):
triple = CommonProperties.property_to_triples(
(_key, _value), local_subject, language)
triples.extend(triple)
if '@type' in json:
rdf_value_type = Namespaces.get_term(json['@type'])
triples.append((local_subject, RDF.type, rdf_value_type))
return triples
def parse_virtual_columns(self, row_node, atdm_row, table_metadata):
for virtual_column in table_metadata['tableSchema']['columns']:
if 'virtual' not in virtual_column or virtual_column[
'virtual'] is False:
continue
subject = URIRef(
UriTemplateUtils.insert_value(virtual_column['aboutUrl'],
atdm_row, '',
table_metadata['url']))
predicate = Namespaces.get_term(virtual_column['propertyUrl'])
obj = UriTemplateUtils.insert_value(virtual_column['valueUrl'],
atdm_row, '',
table_metadata['url'])
obj = CommonProperties.expand_property_if_possible(obj)
self.graph.add((subject, predicate, URIRef(obj)))
if self.mode == CONST_STANDARD_MODE:
self.graph.add((row_node, CSVW.describes, subject))
def create_namespace(property_url, domain_url=''):
property_url = UriTemplateUtils.expand(property_url, domain_url)
if ':' in property_url and '://' not in property_url:
prefix, term = property_url.split(':')
return Namespaces.get(prefix)
if '{' not in property_url:
return Namespace(property_url)
property_key = property_url[property_url.find('{') +
1:property_url.find('}')]
prefix = ''
if property_key.startswith('#'):
property_key = property_key[1:]
property_url = property_url.replace('#', '')
prefix = '#'
if property_key == '_name':
namespace_url = property_url.replace('{_name}', prefix)
return Namespace(namespace_url)
def expand_property(prop):
prefix, prop = prop.split(':')
return Namespaces.get(prefix).term(prop)
def expand_property_if_possible(prop):
if not CommonProperties.is_common_property(prop):
return prop
prefix, prop = prop.split(':')
return Namespaces.get(prefix).term(prop)
def add_default_bindings(graph):
for abbreviation, namespace in Namespaces.all().items():
graph.bind(abbreviation, namespace)
def term(common_property):
"""https://www.w3.org/TR/2015/REC-tabular-metadata-20151217/#common-properties
"""
namespace_abbreviation, term = common_property.split(':')
return Namespaces.get(namespace_abbreviation).term(term)