# © 2020 The MITRE Corporation #This software (or technical data) was produced for the U. S. Government under contract SB-1341-14-CQ-0010, and is subject to the Rights in Data-General Clause 52.227-14, Alt. IV (DEC 2007) #Released under MITRE PRE #18-4297. #==================================================== # CASE API #!/usr/bin/env python import datetime import uuid import rdflib from rdflib import RDF CASE = rdflib.Namespace('http://case.example.org/core#') #==================================================== #-- CREATE A CASE DOCUMENT FOR A SINGLE REPORT class Document(object): def __init__(self, graph=None): """ Initializes the CASE document. Args: graph: The graph to populate (instance of rdflib.Graph) If not provided, a graph in memory will be used. """
with open('io.json') as infile: data = json.load(infile) # Loop through every annotation entry in the json entry = data['protocol'] # Get whatever information you want for your manual step description doi = entry['doi'] steps = entry['steps'] creator = entry['creator']['username'] # print(f'url={url}\nprefix={prefix}\nexact={exact}\nsuffix={suffix}\ntitle={title}') for step in steps: # Some standard ontologies used for nanopubs and describing workflows. NP = rdflib.Namespace("http://www.nanopub.org/nschema#") PPLAN = rdflib.Namespace("http://purl.org/net/p-plan#") PROV = rdflib.Namespace("http://www.w3.org/ns/prov#") DUL = rdflib.Namespace( "http://ontologydesignpatterns.org/wiki/Ontology:DOLCE+DnS_Ultralite/" ) BPMN = rdflib.Namespace("https://www.omg.org/spec/BPMN/") PWO = rdflib.Namespace("http://purl.org/spar/pwo/") PAV = rdflib.Namespace("http://purl.org/pav/") RESEARCHER = rdflib.Namespace("https://www.protocols.io/researchers/") # Now make assertion graph for the nanopub out of this this_np = rdflib.Namespace(doi + '#') this_step = rdflib.term.URIRef(doi + '#step') np_rdf = rdflib.ConjunctiveGraph() head = rdflib.Graph(np_rdf.store, this_np.Head)
def __init__(self): self.rdf = rdflib.Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#') self.sh = rdflib.Namespace('http://www.w3.org/ns/shacl#') self.g = rdflib.Graph() self.nodeShapes = {} self.propertyShapes = {}
import csv import os import rdflib from iribaker import to_iri YAML_NAMESPACE_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'namespaces.yaml') FOAF = rdflib.Namespace('http://xmlns.com/foaf/0.1/') LODE = rdflib.Namespace('http://linkedevents.org/ontology/') IDS = rdflib.Namespace('http://data.socialhistory.org/resource/ids/') TIME = rdflib.Namespace('https://www.w3.org/2006/time#') OWLTIME = rdflib.Namespace("http://www.w3.org/TR/owl-time#") rdf_graph = rdflib.Graph() rdf_graph.bind('foaf', FOAF) rdf_graph.bind('ids', IDS) rdf_graph.bind('lode', LODE) rdf_graph.bind('owltime', OWLTIME) with open("indiv_001smpl.csv") as infile: reader = csv.reader(infile) header = reader.next() for row in reader: personid = row[2] day = str(row[9]).zfill(2) mnth = str(row[10]).zfill(2) year = str(row[11]).zfill(2) date = "{}-{}-{}".format(year, mnth, day) predicate = row[4]
def specgen(template, language): global spec_url global spec_ns global ns_list global namespace_dict # getting all namespaces from o_graph all_ns = [n for n in o_graph.namespace_manager.namespaces()] # creating a dictionary of the names spaces - {identifier:uri} namespace_dict = {key: value for (key, value) in all_ns} if spec_pre in namespace_dict: spec_url = namespace_dict[spec_pre] else: spec_url = namespace_dict[''] spec_ns = rdflib.Namespace(spec_url) # print(get_high_lvl_nodes()) # for x in get_high_lvl_nodes(): # print(x) deprecated_html = create_deprecated_html(o_graph) # Gets sorted classes & property labels class_list = [ get_uri_term((x)) for x in sorted(o_graph.subjects(None, OWL.Class)) ] prop_list = [ get_uri_term((x)) for x in sorted(o_graph.subjects(None, OWL.ObjectProperty)) ] global domain_dict global range_dict domain_dict, range_dict = get_domain_range_dict() # Dict_list in specgen # skos_concepts = [get_uri_term(s) for s, p, o in sorted(o_graph.triples((None, RDF.type, SKOS.ConceptScheme)))] classes_i = sorted([ x for x in class_list if (None, RDF.type, get_full_uri(x)) in o_graph ]) instance_list = get_instances(class_list) # Build HTML list of terms. dict_str = trans_dict["dicts"][l_index] + ":" props_str = trans_dict["props"][l_index] + ":" az_dict = { "Classes:": class_list, props_str: prop_list, "Instances:": instance_list, dict_str: classes_i, } temp_list = [dict_str, "Classes:", props_str, "Instances:"] # create global cross reference azlist_html = get_azlist_html(az_dict, temp_list) # Creating rest of html dict_html = create_dictionary_html(classes_i) classes_html = "<h3 id='classes'>Classes</h3>" + create_terms_html( class_list, "Class") prop_html = "<h3 id='properties'>%s</h3>" % props_str[: -1] + create_terms_html( prop_list, "Property") instance_html = "<h3 id='instances'>Instances</h3>" + create_terms_html( instance_list, "Instance") terms_html = dict_html + classes_html + prop_html + instance_html template = template.format(_header_=get_header_html(), _azlist_=azlist_html, _terms_=terms_html, _deprecated_=deprecated_html) pattern = re.compile( r'importRDFExample\[(?P<label>.*?)\]\[(?P<file>.*?)\]') locate = pattern.search(template) totalExamples = 1 while locate: print("Adding example #", totalExamples, " with title ", locate.groupdict()['label'], ".") template = template.replace( locate.group(), createExamplar(totalExamples, locate.groupdict()['label'], locate.groupdict()['file'])) totalExamples = totalExamples + 1 locate = pattern.search(template) return template
def write_rdf(schema, graph_elements, egg, configG, start_point): predicate = rdflib.Namespace("http://egg/predicate/") named_graph = rdflib.Namespace("http://egg/ng/") g = rdflib.ConjunctiveGraph() ############################################# # write gmark and valid tuples in rdf: begin ############################################# with open("../" + schema + "_output/" + schema + '-graph.txt', 'r') as f: for line in f.readlines(): match = re.match(r"(^(\w+):(\w+) (\w+):(\w+) (\w+):(\w+))", line) if match: s = rdflib.URIRef(match.group(2) + ":" + match.group(3)) o = rdflib.URIRef(match.group(6) + ":" + match.group(7)) if configG[ "ListDynP"]: #write gmark in rdf only if there is properties p = rdflib.URIRef(match.group(4) + ":" + match.group(5)) n = rdflib.URIRef(named_graph + "gmark") g.add((s, p, o, n)) p = rdflib.URIRef(predicate + match.group(4)) for snap in range(0, len(egg[match.group(5)]["v"])): if egg[match.group(5)]["v"][snap] == "T": n = rdflib.URIRef(named_graph + "snapshot" + str(start_point + snap)) g.add((s, p, o, n)) logging.info("1 rdf end") ############################################# # write gmark and valid tuples in rdf: end ############################################# ############################################################ # write value of properties of graph elements in rdf: begin ############################################################ i = 0 for key in graph_elements: for element in graph_elements[key]: s = rdflib.URIRef(key + ":" + str(element)) p = rdflib.URIRef(predicate.hasProperty) if key in configG["nodes"]: for prop in configG["nodes"][key]: o = rdflib.URIRef("Property:" + prop) n = rdflib.URIRef(named_graph + "G" + str(i)) g.add((s, p, o, n)) for snapshot in range(0, len(egg[match.group(5)]["v"])): s1 = rdflib.URIRef(named_graph + "G" + str(i)) p1 = rdflib.URIRef(predicate.value) o1 = rdflib.Literal(str(egg[element][prop][snapshot])) n1 = rdflib.URIRef(named_graph + "snap" + str(start_point + snapshot)) g.add((s1, p1, o1, n1)) i = i + 1 elif key in configG["edges"]: for prop in configG["edges"][key]: o = rdflib.URIRef("Property:" + prop) n = rdflib.URIRef(named_graph + "G" + str(i)) g.add((s, p, o, n)) for snapshot in range(0, len(egg[match.group(5)]["v"])): s1 = rdflib.URIRef(named_graph + "G" + str(i)) p1 = rdflib.URIRef(predicate.value) o1 = rdflib.Literal(str(egg[element][prop][snapshot])) n1 = rdflib.URIRef(named_graph + "snap" + str(start_point + snapshot)) g.add((s1, p1, o1, n1)) i = i + 1 logging.info("2 rdf end") ############################################################ # write value of properties of graph elements in rdf: end ############################################################ ##################################### # serialize rdf graph in trig format ##################################### with open("../" + schema + "_output/" + schema + "-output.trig", "a") as f: f.write(g.serialize(format='trig')) logging.info("rdf end")
from bs4 import BeautifulSoup import os from os import listdir import sys import csv import rdflib, sys from rdflib import * CWRC = rdflib.Namespace( "http://sparql.cwrc.ca/ontologies/cwrc#") BF = rdflib.Namespace( "http://id.loc.gov/ontologies/bibframe/") XML = rdflib.Namespace("http://www.w3.org/XML/1998/namespace") MARCREL = rdflib.Namespace("http://id.loc.gov/vocabulary/relators/") DATA = rdflib.Namespace("http://cwrc.ca/cwrcdata/") GENRE = rdflib.Namespace("http://sparql.cwrc.ca/ontologies/genre#") SCHEMA = rdflib.Namespace("http://schema.org/") TYPE_MAPPING = { "monographic": "standaloneWork", "analytic": "embeddedWork", "journal": "periodical", "series": "series", "unpublished": "unpublished", } def csv_matches(csv_file): col_map = [] mapping = {} with open(csv_file) as f: reader = csv.DictReader(f) for row in reader:
def get_rdf_news(name, in_files, top_entries=None, extra_entries=None, dev_dist=None): import rdflib from time import strptime doap = rdflib.Namespace('http://usefulinc.com/ns/doap#') dcs = rdflib.Namespace('http://ontologi.es/doap-changeset#') rdfs = rdflib.Namespace('http://www.w3.org/2000/01/rdf-schema#') foaf = rdflib.Namespace('http://xmlns.com/foaf/0.1/') rdf = rdflib.Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#') m = rdflib.ConjunctiveGraph() try: for i in in_files: m.parse(i, format='n3') except Exception: Logs.warn('Error parsing data, unable to generate NEWS') return proj = m.value(None, rdf.type, doap.Project) for f in m.triples([proj, rdfs.seeAlso, None]): if f[2].endswith('.ttl'): m.parse(f[2], format='n3') entries = {} for r in m.triples([proj, doap.release, None]): release = r[2] revision = m.value(release, doap.revision, None) date = m.value(release, doap.created, None) blamee = m.value(release, dcs.blame, None) changeset = m.value(release, dcs.changeset, None) dist = m.value(release, doap['file-release'], None) if not dist: Logs.warn('No file release for %s %s' % (proj, revision)) dist = dev_dist if revision and date and blamee and changeset: entry = {} entry['name'] = str(name) entry['revision'] = str(revision) entry['date'] = strptime(str(date), '%Y-%m-%d') entry['status'] = 'stable' if dist != dev_dist else 'unstable' entry['dist'] = str(dist) entry['items'] = [] for i in m.triples([changeset, dcs.item, None]): item = str(m.value(i[2], rdfs.label, None)) entry['items'] += [item] if dist and top_entries is not None: if not str(dist) in top_entries: top_entries[str(dist)] = {'items': []} top_entries[str(dist)]['items'] += [ '%s: %s' % (name, item) ] if extra_entries and dist: for i in extra_entries[str(dist)]: entry['items'] += extra_entries[str(dist)]['items'] entry['blamee_name'] = str(m.value(blamee, foaf.name, None)) entry['blamee_mbox'] = str(m.value(blamee, foaf.mbox, None)) entries[(str(date), str(revision))] = entry else: Logs.warn('Ignored incomplete %s release description' % name) return entries
def on_mapper_add_class(cls, mapper): cls.rdf_type = cls.base_namespace[cls.__name__] cls.rdf_namespace = R.Namespace(cls.rdf_type + "/") return cls
def localish(s): """Return the (almost) local name part of a URI, e.g., http:///www.ex.org/foo -> /foo""" a = s.rfind('/') b = s.rfind('#') if a == -1 and b == -1: return s return s[max(a, b):] # The simplest & safest way to merge is to parse graph from several files: g = rdflib.Graph() g.parse("part1.ttl", format="turtle") g.parse("part2.ttl", format="turtle") n1 = rdflib.Namespace( "http://www.tut.fi/example.org/fi-tut-math-sm-calvin-and-hobbes/") print "This has been asserted about Calvin:" for p, o in g.predicate_objects(n1.Calvin): print " ", localish(p), localish(o) print "And in n3:" g2 = rdflib.Graph() for s, p, o in g.triples((n1.Calvin, None, None)): g2.add((s, p, o)) print(g2.serialize(format="n3"))
import argparse from rdflib import * import rdflib from SPARQLWrapper import SPARQLWrapper, JSON, XML, N3, RDFXML import json import sys CWRC = rdflib.Namespace("http://sparql.cwrc.ca/ontologies/cwrc#") class HuvizQuads: contextGraph = None conjunctiveGraph = ConjunctiveGraph() def __init__(self, instanceUri, graph): self.instanceUri = instanceUri self.graph = graph self.contextGraph = self.get_context_graph() # Do the extraction self.construct_huviz_graph() def get_context_graph(self): """Get Context Graph Arguments: instanceUri {str} -- A string representation of the instance uri Returns:
# Loop through every annotation entry in the json for entry in data: # Get whatever information you want for your manual step description url = entry['url'] user = entry['user'] exact = entry['exact'] created = entry['created'] id = entry['id'] title = entry['title'] # print(f'url={url}\nprefix={prefix}\nexact={exact}\nsuffix={suffix}\ntitle={title}') # Some standard ontologies used for nanopubs and describing workflows. NP = rdflib.Namespace("http://www.nanopub.org/nschema#") PPLAN = rdflib.Namespace("http://purl.org/net/p-plan#") PROV = rdflib.Namespace("http://www.w3.org/ns/prov#") DUL = rdflib.Namespace("http://ontologydesignpatterns.org/wiki/Ontology:DOLCE+DnS_Ultralite/") BPMN = rdflib.Namespace("https://www.omg.org/spec/BPMN/") PWO = rdflib.Namespace("http://purl.org/spar/pwo/") AUT = rdflib.Namespace("https://hypothes.is/a/") # Now make assertion graph for the nanopub out of this this_np = rdflib.Namespace(url+'#') this_step = rdflib.term.URIRef(url + '#step') np_rdf = rdflib.ConjunctiveGraph() head = rdflib.Graph(np_rdf.store, this_np.Head) assertion = rdflib.Graph(np_rdf.store, this_np.assertion) provenance = rdflib.Graph(np_rdf.store, this_np.provenance) pubInfo = rdflib.Graph(np_rdf.store, this_np.pubInfo)
#!/usr/bin/env python # fedora 4 test client # NOTE: this is experimental / spike code!! # (written to get a sense of the fedora 4 LDP API) import requests import rdflib DC = rdflib.Namespace('http://purl.org/dc/elements/1.1/') XMLSchema = rdflib.Namespace('http:////www.w3.org/2001/XMLSchema#') LDP = rdflib.Namespace('http://www.w3.org/ns/ldp#') FEDORA4 = rdflib.Namespace('http://fedora.info/definitions/v4/repository#') # rdf descriptors for easy access to get/set rdf values class Value(object): """A data descriptor that gets a rdf single value. """ # break out into types by xmlschema type, like eulxml? # StringField, DateField, etc. then conversion is easy... # but do we always know what a field will contain? def __init__(self, predicate, datatype=None, normalize=False): self.predicate = predicate self.datatype = datatype self.normalize = normalize def __get__(self, obj, objtype=None):
def main(data, lang): print("Pattern") nif = rdflib.Namespace( "http://persistence.uni-leipzig.org/nlp2rdf/ontologies/nif-core#") count = 0 i = 0 for filename in os.listdir('Files/Input' + lang + '/'): val = 0 if (count < int(data)): graph2 = rdflib.Graph() graph2.parse('Files/Input' + lang + '/' + filename, format='nt') g = Graph() name = filename.split(".")[0] s = graph2.serialize(format="nt") for s, p, o in graph2: if type(o) == rdflib.term.Literal and nif.isString in p: wiki = tokenize(o) for i in wiki: try: BI = val val = val + len(i.encode().decode('utf-8')) + 1 EI = BI + len(str(i.encode().decode('utf-8'))) g.add([ rdflib.term.URIRef( "http://dbpedia.org/resource/" + name + "?dbpv=2016-10&nif=sentence_" + str(BI) + "_" + str(EI)), RDF.type, nif.Sentence ]) g.add([ rdflib.term.URIRef( "http://dbpedia.org/resource/" + name + "?dbpv=2016-10&nif=sentence_" + str(BI) + "_" + str(EI)), nif.beginIndex, rdflib.term.Literal(str(BI)) ]) g.add([ rdflib.term.URIRef( "http://dbpedia.org/resource/" + name + "?dbpv=2016-10&nif=sentence_" + str(BI) + "_" + str(EI)), nif.endIndex, rdflib.term.Literal(str(EI)) ]) g.add([ rdflib.term.URIRef( "http://dbpedia.org/resource/" + name + "?dbpv=2016-10&nif=sentence_" + str(BI) + "_" + str(EI)), nif.anchorOf, rdflib.term.Literal( str(i.encode().decode('utf-8'))) ]) g.add([ rdflib.term.URIRef( "http://dbpedia.org/resource/" + name + "?dbpv=2016-10&nif=sentence_" + str(BI) + "_" + str(EI)), nif.referenceContext, rdflib.term.URIRef( "http://dbpedia.org/resource/" + name + "?dbpv=2016-10&nif=context") ]) except: pass g.bind("nif", nif) g.serialize(destination='Files/Sentence/' + filename, format="turtle") count = count + 1 print("Your Output is stored in Sentence Folder")
def workflows_by_input(nthreads=1, input_types=None, max_inputs=None): logger.info("searching for input list...") collected_inputs = [] t0 = time.time() for w in workflow_context: logger.debug(f"{Fore.BLUE} {w['name']} {Style.RESET_ALL}") logger.debug(f" has " + " ".join([ f"{k}:" + getattr(v, "__name__", "?") for k, v in w['signature'].items() ])) r = w['signature'].get('return', None) largs = typing.get_args(r) if len(largs) == 0: continue larg = largs[0] logger.debug(f"{Fore.GREEN} {larg} {Style.RESET_ALL}") if larg not in input_types: continue logger.info( f"{Fore.YELLOW} valid input generator for {Fore.MAGENTA} {larg.__name__} : {w['function']} {Style.RESET_ALL} {Style.RESET_ALL}" ) for i, arg in enumerate(w['function']()): collected_inputs.append(dict(arg_type=larg, arg=arg)) logger.debug( f"{Fore.BLUE} input: {Fore.MAGENTA} {str(arg):.100s} {Style.RESET_ALL} {Style.RESET_ALL}" ) logger.info("collected %d arguments", len(collected_inputs)) if max_inputs is not None and len(collected_inputs) > max_inputs: logger.warning(f"selecting only %s", max_inputs) break logger.info(f"inputs search done in in {time.time()-t0}") Ex = futures.ThreadPoolExecutor r = [] with Ex(max_workers=nthreads) as ex: for c_id, d in ex.map(workflows_for_input, collected_inputs): logger.debug(f"{c_id} gives: {len(d)}") r.append(d) facts = [] for d in r: for s in d: facts.append(s) logger.info("updating graph..") G = rdflib.Graph() G.bind('paper', rdflib.Namespace('http://odahub.io/ontology/paper#')) if False: D = 'INSERT DATA { ' + " .\n".join(facts) + '}' logger.debug(D) try: G.update(D) except Exception as e: logger.error(f"problem {e} adding \"{s}\"") raise Exception() else: for fact in facts: D = f'INSERT DATA {{ {fact} }}' logger.info(D) try: G.update(D) except Exception as e: logger.error(f"problem {e} adding \"{D}\"") raise Exception(f"problem {e} adding \"{D}\"") r = G.serialize(format='n3') if isinstance(r, bytes): return r.decode() else: return r
class RealSimpleProperty( with_metaclass(ContextMappedPropertyClass, DataUser, Contextualizable)): multiple = False link = R.URIRef("property") linkName = "property" base_namespace = R.Namespace("http://openworm.org/entities/") def __init__(self, owner, **kwargs): super(RealSimpleProperty, self).__init__(**kwargs) self._v = [] self.owner = owner self._hdf = None def contextualize_augment(self, context): self._hdf = None return contextualize_helper(context, self) def has_value(self): for x in self._v: if x.context == self.context: return True return False def has_defined_value(self): if self._hdf is not None: return self._hdf for x in self._v: if x.context == self.context and x.object.defined: self._hdf = True return True return False def set(self, v): if v is None: raise ValueError( 'It is not permitted to declare a property to have value the None' ) if not hasattr(v, 'idl'): v = PropertyValue(v) if not self.multiple: self.clear() stmt = self._insert_value(v) if self.context is not None: self.context.add_statement(stmt) return stmt def clear(self): """ Clears values set *in all contexts* """ self._hdf = None for x in self._v: assert self in x.object.owner_properties x.object.owner_properties.remove(self) self._v.remove(x) @property def defined_values(self): return tuple(x.object for x in self._v if x.object.defined and x.context == self.context) @property def values(self): return tuple(x.object for x in self._v if x.context == self.context) @property def rdf(self): if self.context is not None: return self.context.rdf_graph() else: return self.conf['rdf.graph'] @property def identifier(self): return self.link def get(self): if self.rdf is None: return () results = None owner = self.owner if owner.defined: self._ensure_fresh_po_cache() results = set() for pred, obj in owner.po_cache.cache: if pred == self.link: results.add(obj) else: v = Variable("var" + str(id(self))) self._insert_value(v) results = GraphObjectQuerier(v, self.rdf, parallel=False)() self._remove_value(v) return results def _insert_value(self, v): stmt = Statement(self.owner, self, v, self.context) self._hdf = None self._v.append(stmt) if self not in v.owner_properties: v.owner_properties.append(self) return stmt def _remove_value(self, v): assert self in v.owner_properties self._hdf = None v.owner_properties.remove(self) self._v.remove(Statement(self.owner, self, v, self.context)) def _ensure_fresh_po_cache(self): owner = self.owner ident = owner.identifier graph_index = self.conf.get('rdf.graph.change_counter', None) if graph_index is None or owner.po_cache is None or owner.po_cache.cache_index != graph_index: owner.po_cache = POCache( graph_index, frozenset(self.rdf.predicate_objects(ident))) def unset(self, v): self._remove_value(v) def __call__(self, *args, **kwargs): return _get_or_set(self, *args, **kwargs) def __repr__(self): fcn = FCN(type(self)) return '{}(owner={})'.format(fcn, repr(self.owner)) def one(self): return next(iter(self.get()), None) def onedef(self): for x in self._v: if x.object.defined and x.context == self.context: return x.object return None @classmethod def on_mapper_add_class(cls, mapper): cls.rdf_type = cls.base_namespace[cls.__name__] cls.rdf_namespace = R.Namespace(cls.rdf_type + "/") return cls @property def defined_statements(self): return tuple(x for x in self._v if x.object.defined and x.subject.defined) @property def statements(self): return self.rdf.quads((self.owner.idl, self.link, None, None))
class NS: test = r.Namespace( "http://purl.org/socialparticipation/test/") # caixa mágica cm = r.Namespace("http://purl.org/socialparticipation/cm/") # caixa mágica obs = r.Namespace("http://purl.org/socialparticipation/obs/" ) # ontology of the social library aa = r.Namespace("http://purl.org/socialparticipation/aa/" ) # algorithmic autoregulation vbs = r.Namespace("http://purl.org/socialparticipation/vbs/" ) # vocabulary of the social library opa = r.Namespace( "http://purl.org/socialparticipation/opa/") # participabr ops = r.Namespace("http://purl.org/socialparticipation/ops/" ) # social participation ontology ocd = r.Namespace( "http://purl.org/socialparticipation/ocd/") # cidade democrática ore = r.Namespace( "http://purl.org/socialparticipation/ore/" ) # ontology of the reseach, for registering ongoing works, a RDF AA ot = r.Namespace( "http://purl.org/socialparticipation/ot/" ) # ontology of the thesis, for academic conceptualizations po = r.Namespace("http://purl.org/socialparticipation/po/" ) # the participation ontology, this framework itself per = r.Namespace("http://purl.org/socialparticipation/per/" ) # percolation, this framework itself social = r.Namespace("http://purl.org/socialparticipation/social/" ) # percolation, this framework itself participation = r.Namespace( "http://purl.org/socialparticipation/participation/" ) # percolation, this framework itself facebook = r.Namespace( "http://purl.org/socialparticipation/facebook/") # facebook tw = r.Namespace("http://purl.org/socialparticipation/tw/") # twitter irc = r.Namespace("http://purl.org/socialparticipation/irc/") # irc gmane = r.Namespace("http://purl.org/socialparticipation/gmane/") # gmane ld = r.Namespace("http://purl.org/socialparticipation/ld/") # linkedin aavo = r.Namespace("http://purl.org/audiovisualanalytics/") aav = r.Namespace("http://purl.org/audiovisualanalytics/vocabulary/") aao = r.Namespace("http://purl.org/audiovisualanalytics/ontology/") voeiia = r.Namespace("http://purl.org/audiovisualanalytics/voeiia/") dbp = r.Namespace("http://dbpedia.org/resource/") rdf = r.namespace.RDF rdfs = r.namespace.RDFS owl = r.namespace.OWL xsd = r.namespace.XSD dc = r.namespace.DC dct = r.namespace.DCTERMS foaf = r.namespace.FOAF doap = r.namespace.DOAP void = r.namespace.VOID skos = r.namespace.SKOS U = r.URIRef
def convert(self, csvreader): start = time.time() if self.OUT: sys.stderr.write("Output to %s\n" % self.OUT.name) if self.IDENT != "auto" and not isinstance(self.IDENT, tuple): self.IDENT = (self.IDENT,) if not self.BASE: warnings.warn("No base given, using http://example.org/instances/") self.BASE = rdflib.Namespace("http://example.org/instances/") if not self.PROPBASE: warnings.warn( "No property base given, using http://example.org/property/") self.PROPBASE = rdflib.Namespace("http://example.org/props/") # skip lines at the start for x in range(self.SKIP): next(csvreader) # read header line header_labels = list(next(csvreader)) headers = dict( enumerate([self.PROPBASE[toProperty(x)] for x in header_labels])) # override header properties if some are given for k, v in self.PROPS.items(): headers[k] = v header_labels[k] = split_uri[1] if self.DEFINECLASS: # output class/property definitions self.triple(self.CLASS, RDF.type, RDFS.Class) for i in range(len(headers)): h, l = headers[i], header_labels[i] if h == "" or l == "": continue if self.COLUMNS.get(i) == "ignore": continue self.triple(h, RDF.type, RDF.Property) self.triple(h, RDFS.label, rdflib.Literal(toPropertyLabel(l))) self.triple(h, RDFS.domain, self.CLASS) self.triple(h, RDFS.range, self.COLUMNS.get(i, default_node_make).range()) rows = 0 for l in csvreader: try: if self.IDENT == 'auto': uri = self.BASE["%d" % rows] else: uri = self.BASE["_".join([urllib.parse.quote(x.encode( "utf8").replace(" ", "_"), safe="") for x in index(l, self.IDENT)])] if self.LABEL: self.triple(uri, RDFS.label, rdflib.Literal( " ".join(index(l, self.LABEL)))) if self.CLASS: # type triple self.triple(uri, RDF.type, self.CLASS) for i, x in enumerate(l): x = x.strip() if x != '': if self.COLUMNS.get(i) == "ignore": continue try: o = self.COLUMNS.get(i, rdflib.Literal)(x) if isinstance(o, list): for _o in o: self.triple(uri, headers[i], _o) else: self.triple(uri, headers[i], o) except Exception as e: warnings.warn( "Could not process value for column " + "%d:%s in row %d, ignoring: %s " % ( i, headers[i], rows, e.message)) rows += 1 if rows % 100000 == 0: sys.stderr.write( "%d rows, %d triples, elapsed %.2fs.\n" % ( rows, self.triples, time.time() - start)) except: sys.stderr.write("Error processing line: %d\n" % rows) raise # output types/labels for generated URIs classes = set() for l, x in uris.items(): u, c = x self.triple(u, RDFS.label, rdflib.Literal(l)) if c: c = rdflib.URIRef(c) classes.add(c) self.triple(u, RDF.type, c) for c in classes: self.triple(c, RDF.type, RDFS.Class) self.OUT.close() sys.stderr.write( "Converted %d rows into %d triples.\n" % (rows, self.triples)) sys.stderr.write("Took %.2f seconds.\n" % (time.time() - start))
newGraphSize = len(rdfGraph) logging.info(f'\t{newGraphSize - graphSize} statements read from {srcFile.name}') graphSize = newGraphSize case _: raise NotImplementedError(f'source {src} not yet implemented!') logging.info(f'data graph now has {len(rdfGraph)} statements') # check data if config.getboolean('WORK', 'checkData'): for (subj, pred, obj) in rdfGraph: print(subj, pred, obj) # set bindings logging.debug('Namespaces\n\t{:s}'.format('\n\t'.join(map(str, rdfGraph.namespaces())))) nsDict = dict(rdfGraph.namespaces()) mo = rdflib.Namespace(nsDict['mo']) # read data if config.getboolean('WORK', 'checkData'): for (subj, pred, obj) in rdfGraph: print(subj, pred, obj) # uriRef = rdflib.term.URIRef(value="https://www.mathematik-olympiaden.de/aufgaben/rdf/Problem#MO-511341") # print(uriRef) # for (pred, obj) in rdfGraph.predicate_objects(subject=uriRef): # print(rdfGraph.label(pred), obj) # query data: MO if config.getboolean('WORK', 'queryData'): queryStr = 'SELECT $nr $pdfA $oly $rnd $okl \ WHERE { \ $problem a mo:Problem . \
def main(): csv2rdf = CSV2RDF() opts, files = getopt.getopt( sys.argv[1:], "hc:b:p:i:o:Cf:l:s:d:", ["out=", "base=", "delim=", "propbase=", "class=", "ident=", "label=", "skip=", "defineclass", "help"]) opts = dict(opts) if "-h" in opts or "--help" in opts: print(HELP) sys.exit(-1) if "-f" in opts: config = configparser.ConfigParser() config.readfp(open(opts["-f"])) for k, v in config.items("csv2rdf"): if k == "out": csv2rdf.OUT = codecs.open(v, "w", "utf-8") elif k == "base": csv2rdf.BASE = rdflib.Namespace(v) elif k == "propbase": csv2rdf.PROPBASE = rdflib.Namespace(v) elif k == "class": csv2rdf.CLASS = rdflib.URIRef(v) elif k == "defineclass": csv2rdf.DEFINECLASS = bool(v) elif k == "ident": csv2rdf.IDENT = eval(v) elif k == "label": csv2rdf.LABEL = eval(v) elif k == "delim": csv2rdf.DELIM = v elif k == "skip": csv2rdf.SKIP = int(v) elif k.startswith("col"): csv2rdf.COLUMNS[int(k[3:])] = column(v) elif k.startswith("prop"): csv2rdf.PROPS[int(k[4:])] = rdflib.URIRef(v) if "-o" in opts: csv2rdf.OUT = codecs.open(opts["-o"], "w", "utf-8") if "--out" in opts: csv2rdf.OUT = codecs.open(opts["--out"], "w", "utf-8") if "-b" in opts: csv2rdf.BASE = rdflib.Namespace(opts["-b"]) if "--base" in opts: csv2rdf.BASE = rdflib.Namespace(opts["--base"]) if "-d" in opts: csv2rdf.DELIM = opts["-d"] if "--delim" in opts: csv2rdf.DELIM = opts["--delim"] if "-p" in opts: csv2rdf.PROPBASE = rdflib.Namespace(opts["-p"]) if "--propbase" in opts: csv2rdf.PROPBASE = rdflib.Namespace(opts["--propbase"]) if "-l" in opts: csv2rdf.LABEL = eval(opts["-l"]) if "--label" in opts: csv2rdf.LABEL = eval(opts["--label"]) if "-i" in opts: csv2rdf.IDENT = eval(opts["-i"]) if "--ident" in opts: csv2rdf.IDENT = eval(opts["--ident"]) if "-s" in opts: csv2rdf.SKIP = int(opts["-s"]) if "--skip" in opts: csv2rdf.SKIP = int(opts["--skip"]) if "-c" in opts: csv2rdf.CLASS = rdflib.URIRef(opts["-c"]) if "--class" in opts: csv2rdf.CLASS = rdflib.URIRef(opts["--class"]) for k, v in opts.items(): if k.startswith("--col"): csv2rdf.COLUMNS[int(k[5:])] = column(v) elif k.startswith("--prop"): csv2rdf.PROPS[int(k[6:])] = rdflib.URIRef(v) if csv2rdf.CLASS and ("-C" in opts or "--defineclass" in opts): csv2rdf.DEFINECLASS = True csv2rdf.convert( csv_reader(fileinput.input(files), delimiter=csv2rdf.DELIM))
from versa import VERSA_BASEIRI from versa.reader.md import from_markdown #Represent the blank node RDF-ism class mock_bnode(I): ''' Must be initialized with a string. Just use '' ''' def __new__(cls, _): new_id = '__VERSABLANKNODE__' + str(hash(datetime.datetime.now().isoformat())) #str(id(object())) #Fake an ID self = super(mock_bnode, cls).__new__(cls, new_id) return self VERSA_TYPE = I(VERSA_BASEIRI + 'type') VNS = rdflib.Namespace(VERSA_BASEIRI) RDF_NS = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' RDFS_NS = 'http://www.w3.org/2000/01/rdf-schema#' RDF_TYPE = I(RDF_NS + 'type') def prep(s, p, o): ''' Prepare a triple for rdflib ''' def bnode_check(r): return isinstance(r, mock_bnode) or r.startswith('VERSABLANKNODE_') s = BNode() if bnode_check(s) else URIRef(s)
"""Grab Collections Graphs from Fedora, Iterate, and load into local Fuseki.""" import rdflib from rdflib.namespace import * from argparse import ArgumentParser import sys fcrepo_base = 'http://hydraedit-dev.library.cornell.edu:8080/fedora/rest/dev/' EDM = rdflib.Namespace('http://www.europeana.eu/schemas/edm/') PCDM = rdflib.Namespace('http://pcdm.org/models#') FEDORA = rdflib.Namespace('http://fedora.info/definitions/v4/repository#') ONS = rdflib.Namespace('http://opaquenamespace.org/hydra/') VIVO = rdflib.Namespace('http://vivoweb.org/ontology/core#') HW = rdflib.Namespace('http://projecthydra.org/works/models#') MARCREL = rdflib.Namespace('http://id.loc.gov/vocabulary/relators/') FCONFIG = rdflib.Namespace('http://fedora.info/definitions/v4/config#') LDP = rdflib.Namespace('http://www.w3.org/ns/ldp#') def grabCollContainers(cont, fcrepo): """Query fedora for all resources of the selected collection.""" print("Generating graph.") cont_g = fcrepo.parse(cont) s = 0 print("Parsing graph objects.") for obj in cont_g.objects(cont, LDP.contains): # Parse recursively on that graph through Works, Parts, Filesets. cont_g.parse(rdflib.term.URIRef(obj)) if (s % 100) == 0 and s != 0: print("%d URIs processed" % s) s += 1 return (cont_g)
from pygments.formatters import HtmlFormatter # temp log library for debugging # from log import * # log = Log("log/docgen") # log.test_name("Debugging Document Generator") spec_url = None spec_ns = None spec_pre = None lang = None bibo_nodes = None o_graph = None deprecated_uris = None # Important nspaces RDF = rdflib.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#") RDFS = rdflib.Namespace("http://www.w3.org/2000/01/rdf-schema#") SKOS = rdflib.Namespace("http://www.w3.org/2004/02/skos/core#") OWL = rdflib.Namespace("http://www.w3.org/2002/07/owl#") FOAF = rdflib.Namespace("http://xmlns.com/foaf/0.1/") VANN = rdflib.Namespace("http://purl.org/vocab/vann/") PROV = rdflib.Namespace("http://www.w3.org/ns/prov#") DCTERMS = rdflib.Namespace("http://purl.org/dc/terms/") trans_dict = { "specification": ["Specification", "Spécifications"], "draft": ["Working Draft", "Brouillon de travail"], "previous_ver": ["Previous Version", "Ancienne version"], "current_ver": ["This Version", "Version courante"], "latest_ver": ["Latest Version", "Version à jour"], "last_ver": ["Last update", "Dernière version"],
# A BioPax term and possible value for ComponentDefinition::type property BIOPAX_COMPLEX = "http://www.biopax.org/release/biopax-level3.owl#Complex" # EDAM ontology is used for Model.languages # An EDAM ontology term and option for Model::language EDAM_SBML = "http://identifiers.org/edam/format_2585" # An EDAM ontology term and option for Model::language EDAM_CELLML = "http://identifiers.org/edam/format_3240" # An EDAM ontology term and option for Model::language EDAM_BIOPAX = "http://identifiers.org/edam/format_3156" # Model.frameworks # SBO term and option for Model::framework SBO_CONTINUOUS = SBO + "0000062" # SBO term and option for Model::framework SBO_DISCRETE = SBO + "0000063" # URIs for SBOL extension objects SYSBIO_DESIGN = SYSBIO_URI + "#Design" SYSBIO_BUILD = SYSBIO_URI + "#Build" SYSBIO_TEST = SYSBIO_URI + "#Test" SYSBIO_ANALYSIS = SYSBIO_URI + "#Analysis" SYSBIO_SAMPLE_ROSTER = SYSBIO_URI + "#SampleRoster" IGEM_URI = "http://wiki.synbiohub.org/wiki/Terms/igem" OM_NS = rdflib.Namespace(OM_URI) OM_MEASURE: str = OM_NS.Measure.toPython() OM_HAS_UNIT: str = OM_NS.hasUnit.toPython() OM_HAS_NUMERICAL_VALUE: str = OM_NS.hasNumericalValue.toPython()
def configure_database(self): """ Database configuration should be set here """ self.NS = NamespaceContainer() self.NS.RDFS = rdflib.RDFS self.NS.RDF = rdflib.RDF self.NS.rdfs = rdflib.Namespace(rdflib.RDFS) self.NS.rdf = rdflib.Namespace(rdflib.RDF) self.NS.owl = rdflib.OWL self.NS.xsd = rdflib.Namespace("http://www.w3.org/2001/XMLSchema#") self.NS.dc = rdflib.Namespace("http://purl.org/dc/terms/") self.NS.dcelements = rdflib.Namespace("http://purl.org/dc/elements/1.1/") self.NS.auth = rdflib.Namespace("http://vocab.rpi.edu/auth/") self.NS.foaf = rdflib.Namespace("http://xmlns.com/foaf/0.1/") self.NS.prov = rdflib.Namespace("http://www.w3.org/ns/prov#") self.NS.skos = rdflib.Namespace("http://www.w3.org/2004/02/skos/core#") self.NS.cmo = rdflib.Namespace("http://purl.org/twc/ontologies/cmo.owl#") self.NS.sio = rdflib.Namespace("http://semanticscience.org/resource/") self.NS.sioc_types = rdflib.Namespace("http://rdfs.org/sioc/types#") self.NS.sioc = rdflib.Namespace("http://rdfs.org/sioc/ns#") self.NS.np = rdflib.Namespace("http://www.nanopub.org/nschema#") self.NS.graphene = rdflib.Namespace("http://vocab.rpi.edu/graphene/") self.NS.local = rdflib.Namespace(self.config['lod_prefix']+'/') self.NS.ov = rdflib.Namespace("http://open.vocab.org/terms/") self.db = database.engine_from_config(self.config, "db_") load_namespaces(self.db,locals()) Resource.db = self.db self.vocab = Graph() #print URIRef(self.config['vocab_file']) self.vocab.load(open(self.config['vocab_file']), format="turtle") self.role_api = ld.LocalResource(self.NS.prov.Role,"role", self.db.store, self.vocab, self.config['lod_prefix'], RoleMixin) self.Role = self.role_api.alchemy self.user_api = ld.LocalResource(self.NS.prov.Agent,"user", self.db.store, self.vocab, self.config['lod_prefix'], UserMixin) self.User = self.user_api.alchemy self.nanopub_api = ld.LocalResource(self.NS.np.Nanopublication,"pub", self.db.store, self.vocab, self.config['lod_prefix'], name="Graph") self.Nanopub = self.nanopub_api.alchemy self.classes = mapper(self.Role, self.User) self.datastore = RDFAlchemyUserDatastore(self.db, self.classes, self.User, self.Role) self.security = Security(self, self.datastore, register_form=ExtendedRegisterForm)
from csvw_validation_test_cases import implementation_report __author__ = 'sebastian' import rdflib from rdflib.namespace import FOAF EARL = rdflib.Namespace("http://www.w3.org/ns/earl#") class ImplementationReport(): def __init__(self): self.g = rdflib.Graph() self.g.parse(location='test/doap.ttl', format='turtle') for person in self.g.subjects(rdflib.RDF.type, FOAF.Person): self.assertor = person break for subj in self.g.subjects(rdflib.RDF.type, EARL.TestSubject): self.subject = subj break def run_validation_test(self): implementation_report(self.g, self.subject, self.assertor) def getResult(self): return self.g.serialize(format='turtle') if __name__ == '__main__': rep = ImplementationReport() rep.run_validation_test() res = rep.getResult() print res
class ShapeParserTests(unittest.TestCase): w3c_test_files = 'tests/_files/w3c' ex = rdflib.Namespace('http://www.example.org/') def setUp(self): self.parser = ShapeParser() self.dir = path.abspath('tests/_files') def tearDown(self): self.parser = None self.dir = None def testParsingW3CFiles(self): """Test if all W3C samples are parsed without throwing an error.""" for root, dirs, files in os.walk(self.w3c_test_files): for f in files: shapes = ShapeParser().parseShape( path.join(self.w3c_test_files, f)) self.assertTrue(isinstance(shapes, dict)) def testAddressShape(self): """Test Adress Shape example.""" nodeShapesDict = ShapeParser().parseShape( path.join(self.w3c_test_files, 'AddressShape.ttl')) addressShape = nodeShapesDict[str(self.ex.AddressShape)] personShape = nodeShapesDict[str(self.ex.PersonShape)] postalCodeShape = addressShape.properties[0] addressPropertyShape = personShape.properties[0] self.assertEqual(len(nodeShapesDict), 2) self.assertEqual(len(addressShape.properties), 1) self.assertEqual(len(personShape.properties), 1) self.assertEqual(addressShape.uri, str(self.ex.AddressShape)) self.assertEqual(personShape.uri, str(self.ex.PersonShape)) self.assertEqual(postalCodeShape.path, str(self.ex.postalCode)) self.assertEqual(postalCodeShape.datatype, str(XSD.string)) self.assertEqual(postalCodeShape.maxCount, 1) self.assertEqual(addressPropertyShape.path, str(self.ex.address)) self.assertEqual(addressPropertyShape.minCount, 1) self.assertEqual(addressPropertyShape.nodes[0], str(self.ex.AddressShape)) def testClassExampleShape(self): """Test Class example.""" nodeShapesDict = ShapeParser().parseShape( path.join(self.w3c_test_files, 'ClassExampleShape.ttl')) nodeShape = nodeShapesDict[str(self.ex.ClassExampleShape)] propertyShape = nodeShape.properties[0] self.assertEqual(nodeShape.uri, str(self.ex.ClassExampleShape)) self.assertTrue(str(self.ex.Alice) in nodeShape.targetNode) self.assertTrue(str(self.ex.Bob) in nodeShape.targetNode) self.assertTrue(str(self.ex.Carol) in nodeShape.targetNode) self.assertTrue(len(nodeShape.targetNode), 3) self.assertTrue(len(nodeShapesDict), 1) self.assertEqual(propertyShape.path, str(self.ex.address)) self.assertEqual(propertyShape.classes[0], str(self.ex.PostalAddress)) self.assertTrue(len(propertyShape.classes), 1) def testHand(self): """Test qualifiedValueShapes of Hand example.""" nodeShapesDict = ShapeParser().parseShape( path.join(self.w3c_test_files, 'HandShape.ttl')) self.assertEqual(len(nodeShapesDict), 1) for id, nodeShape in nodeShapesDict.items(): values = { 'http://www.example.org/Finger': 4, 'http://www.example.org/Thumb': 1 } for propertyShape in nodeShape.properties: if propertyShape.isSet['qualifiedValueShape']: # One thumb and four fingers self.assertTrue( propertyShape.isSet['qualifiedValueShapesDisjoint']) self.assertEqual(propertyShape.path, str(self.ex.digit)) self.assertEqual( values[propertyShape.qualifiedValueShape.classes[0]], propertyShape.qualifiedMinCount) self.assertEqual( values[propertyShape.qualifiedValueShape.classes[0]], propertyShape.qualifiedMaxCount) else: # Hand self.assertEqual(propertyShape.path, str(self.ex.digit)) self.assertFalse( propertyShape.isSet['qualifiedValueShapesDisjoint']) self.assertEqual(propertyShape.maxCount, 5) def testMinMaxLogic(self): # not part of the shacl constraints, can be reimplemented though # with self.assertRaises(Exception): # ShapeParser().parseShape(path.join(self.dir, 'minGreaterMax.ttl')) # with self.assertRaises(Exception): # ShapeParser().parseShape(path.join(self.dir, 'maxLowerMin.ttl')) # with self.assertRaises(Exception): # ShapeParser().parseShape(path.join(self.dir, 'multipleMinCounts.ttl')) # with self.assertRaises(Exception): # ShapeParser().parseShape(path.join(self.dir, 'multipleMaxCounts.ttl')) shapes = ShapeParser().parseShape( path.join(self.dir, 'minLowerMax.ttl')) self.assertEqual( shapes['http://www.example.org/ExampleShape'].properties[0]. minCount, 1) self.assertEqual( shapes['http://www.example.org/ExampleShape'].properties[0]. maxCount, 2) def testPositiveNodeShapeParse(self): nodeShapes = self.parser.parseShape( self.dir + '/positiveNodeShapeParserExample1.ttl') nodeShape = nodeShapes[('http://www.example.org/exampleShape')] self.assertEqual(str(nodeShape.uri), 'http://www.example.org/exampleShape') targetClasses = [ 'http://www.example.org/Animal', 'http://www.example.org/Person' ] self.assertEqual(sorted(nodeShape.targetClass), targetClasses) targetNodes = [ 'http://www.example.org/Alice', 'http://www.example.org/Bob' ] self.assertEqual(sorted(nodeShape.targetNode), targetNodes) relationships = [ 'http://www.example.org/friendship', 'http://www.example.org/relationship' ] self.assertEqual(sorted(nodeShape.targetObjectsOf), relationships) self.assertEqual(sorted(nodeShape.targetSubjectsOf), relationships) self.assertEqual(str(nodeShape.nodeKind), 'http://www.w3.org/ns/shacl#IRI') self.assertEqual(nodeShape.closed, True) ignoredProperties = [ 'http://www.example.org/A', 'http://www.example.org/B', 'http://www.example.org/C' ] self.assertEqual(sorted(nodeShape.ignoredProperties), ignoredProperties) self.assertEqual(str(nodeShape.message['default']), "C") self.assertEqual(str(nodeShape.message['en']), "A") self.assertEqual(str(nodeShape.message['de']), "B") self.assertEqual(len(nodeShape.properties), 2) def testPositiveNodeShapePropertiesParse(self): nodeShapes = self.parser.parseShape( self.dir + '/positivePropertyShapeParserExample.ttl') nodeShape = nodeShapes['http://www.example.org/exampleShape'] for shape in nodeShape.properties: if str(shape.path) == 'http://www.example.org/PathA': propertyShapeA = shape else: propertyShapeB = shape classes = ['http://www.example.org/A', 'http://www.example.org/B'] self.assertEqual(sorted(propertyShapeA.classes), classes) self.assertEqual(propertyShapeA.datatype, 'http://www.w3.org/2001/XMLSchema#integer') self.assertEqual(int(propertyShapeA.minCount), 1) self.assertEqual(int(propertyShapeA.maxCount), 2) self.assertEqual(int(propertyShapeA.minExclusive), 1) self.assertEqual(int(propertyShapeA.maxExclusive), 1) self.assertEqual(int(propertyShapeA.minInclusive), 1) self.assertEqual(int(propertyShapeA.maxInclusive), 1) self.assertEqual(int(propertyShapeA.minLength), 1) self.assertEqual(int(propertyShapeA.maxLength), 2) self.assertEqual(str(propertyShapeA.pattern), '[abc]') self.assertEqual(str(propertyShapeA.flags), 'i') languageIn = ['de', 'en'] self.assertEqual(sorted(propertyShapeA.languageIn), languageIn) self.assertEqual(propertyShapeA.uniqueLang, True) equals = [ 'http://www.example.org/PathB', 'http://www.example.org/PathC' ] self.assertEqual(sorted(propertyShapeA.equals), equals) disjoint = [ 'http://www.example.org/PathB', 'http://www.example.org/PathC' ] self.assertEqual(sorted(propertyShapeA.disjoint), disjoint) lessThan = ['http://www.example.org/A', 'http://www.example.org/B'] self.assertEqual(sorted(propertyShapeA.lessThan), lessThan) lessThanOrEquals = [ 'http://www.example.org/A', 'http://www.example.org/B' ] self.assertEqual(sorted(propertyShapeA.lessThanOrEquals), lessThanOrEquals) nodes = [ 'http://www.example.org/propertyShapeA', 'http://www.example.org/propertyShapeB' ] self.assertEqual(sorted(propertyShapeA.nodes), nodes) qualifiedValueShape = [ 'http://www.example.org/friendship', 'http://www.example.org/relationship' ] self.assertEqual(str(propertyShapeA.qualifiedValueShape.path), 'http://www.example.org/PathC') self.assertEqual(propertyShapeA.qualifiedValueShapesDisjoint, True) self.assertEqual(int(propertyShapeA.qualifiedMinCount), 1) self.assertEqual(int(propertyShapeA.qualifiedMaxCount), 2) self.assertEqual(str(propertyShapeA.name['default']), "C") self.assertEqual(str(propertyShapeA.name['en']), "A") self.assertEqual(str(propertyShapeA.name['de']), "B") self.assertEqual(str(propertyShapeA.description['default']), "C") self.assertEqual(str(propertyShapeA.description['en']), "A") self.assertEqual(str(propertyShapeA.description['de']), "B") self.assertEqual(str(propertyShapeB.path), 'http://www.example.org/PathB') def testUnusedPropertyShapeParse(self): wellFormedShapes = self.parser.parseShape( self.dir + '/w3c/ExampleNodeShapeWithPropertyShapes.ttl') self.assertEqual(len(wellFormedShapes), 1) def testUsedPropertyShapeParse(self): wellFormedShapes = self.parser.parseShape( self.dir + '/positiveUsedPropertyShape.ttl') self.assertEqual( len(wellFormedShapes[str( self.ex.PositiveUsedPropertyShape)].properties), 2)
* system content * registers that are just containers for other registers ''' import rdflib from rdflib.namespace import RDF, RDFS import uuid import logging from ckan.common import OrderedDict from ckanext.harvest.harvesters.base import HarvesterBase import ckan.plugins as p from ckanext.dgu.lib.formats import Formats REG = rdflib.Namespace('http://purl.org/linked-data/registry#') SKOS = rdflib.Namespace('http://www.w3.org/2004/02/skos/core#') OWL = rdflib.Namespace('http://www.w3.org/2002/07/owl#') LDP = rdflib.Namespace('http://www.w3.org/ns/ldp#') DCT = rdflib.Namespace('http://purl.org/dc/terms/') # DGU_type DGU_TYPE__CODE_LIST = 'Code list' DGU_TYPE__ONTOLOGY = 'Ontology' DGU_TYPE__CONTROLLED_LIST = 'Controlled list' TTL_PARAM = '?_format=ttl' METADATA_PARAM = '&_view=with_metadata' def printable_uri(uri):
import rdflib import os import flask_ld as ld import collections import requests import tempfile from depot.io.utils import FileIntent from depot.manager import DepotManager from datetime import datetime import pytz np = rdflib.Namespace("http://www.nanopub.org/nschema#") prov = rdflib.Namespace("http://www.w3.org/ns/prov#") dc = rdflib.Namespace("http://purl.org/dc/terms/") frbr = rdflib.Namespace("http://purl.org/vocab/frbr/core#") from uuid import uuid4 class Nanopublication(rdflib.ConjunctiveGraph): _nanopub_resource = None @property def nanopub_resource(self): if self._nanopub_resource is None: self._nanopub_resource = self.resource(self.identifier) if not self._nanopub_resource[rdflib.RDF.type:np.Nanopublication]: self._nanopub_resource.add(rdflib.RDF.type, np.Nanopublication)
import rdflib import os.path __all__ = ['licenses'] FOAF = rdflib.Namespace('http://xmlns.com/foaf/0.1/') DCTERMS = rdflib.Namespace('http://purl.org/dc/terms/') DCTYPE = rdflib.Namespace('http://purl.org/dc/dcmitype/') RDF = rdflib.Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#') class _License(object): def __init__(self, graph, uri): self._graph, self._uri = graph, uri def get(self, p): for o in self._graph.objects(self._uri, p): return unicode(o) return None def __unicode__(self): return self.get(DCTERMS['title']) @property def logo(self): return self.get(FOAF['logo']) def simplify_for_render(self, simplify_value, simplify_model): simplified = {} for predicate, object in self._graph.predicate_objects(self._uri): # Disregard type