def get_profiles(): realprofiles=dict() realprofileindices=dict() annotationpool=[] out=open("../results/EvolutionaryProfileSizes.tsv",'w') register('text/rdf+n3', Parser, 'rdflib.plugins.parsers.notation3', 'N3Parser') g = rdflib.Graph() result = g.parse('../data/realprofilesold.ttl', format='n3') index=0 for stmt in g: profileid=stmt[0] annotation=stmt[2] if "VTO" in profileid: profileid=profileid.replace("http://purl.obolibrary.org/obo/","").replace("#profile","") if profileid not in realprofiles: realprofiles[profileid]=set() realprofiles[profileid].add(annotation) annotationpool.append(annotation) if profileid not in realprofileindices: realprofileindices[profileid]=set() realprofileindices[profileid].add(index) index+=1 print "Created real profiles" for profileid in realprofiles: out.write(profileid+"\t"+str(len(realprofiles[profileid]))+"\n") return realprofiles,annotationpool,realprofileindices
def __init__(self, gc): ''' Constructor ''' self.__globalContext = gc plugin.register("sparql", query.Processor, "rdfextras.sparql.processor", "Processor") plugin.register("sparql", query.Result, "rdfextras.sparql.query", "SPARQLQueryResult")
def registerplugins(): """ Register plugins. If setuptools is used to install rdflib-sqlalchemy, all the provided plugins are registered through entry_points. This is strongly recommended. However, if only distutils is available, then the plugins must be registed manually. This method will register all of the rdflib-sqlalchemy Store plugins. """ from rdflib.store import Store from rdflib import plugin try: x = plugin.get("SQLAlchemy", Store) del x return # plugins already registered except: pass # must register plugins # Register the plugins ... plugin.register( "SQLAlchemy", Store, "rdflib_sqlalchemy.store", "SQLAlchemy", )
def __register_Turtle_serializer(formatstring) : """The default Turtle Serializers of RDFlib is buggy and not very nice as far as the output is concerned. An L{own version<serializers.TurtleSerializer>} is registered in RDFLib and used in the rest of the package. @param formatstring: the string to identify this serializer with. """ from rdflib.plugin import register from rdflib.syntax import serializer, serializers register(formatstring, serializers.Serializer, "pyRdfa.serializers.TurtleSerializer", "TurtleSerializer")
def _register_JSON_serializer_3(self) : """JSON LD serializer """ if not MyGraph.json_serializer_registered : from rdflib.plugin import register from rdflib.serializer import Serializer register(_json_serializer_name, Serializer, "pyRdfaExtras.serializers.jsonserializer", "JsonSerializer") MyGraph.json_serializer_registered = True
def __register_XML_serializer(formatstring) : """The default XML Serializer of RDFlib is buggy, mainly when handling lists. An L{own version<serializers.PrettyXMLSerializer>} is registered in RDFlib and used in the rest of the package. @param formatstring: the string to identify this serializer with. """ from rdflib.plugin import register from rdflib.syntax import serializer, serializers register(formatstring, serializers.Serializer, "pyRdfa.serializers.PrettyXMLSerializer", "PrettyXMLSerializer")
def _register_XML_serializer_3(self) : """The default XML Serializer of RDFLib 3.X is buggy, mainly when handling lists. An L{own version<serializers.prettyXMLserializer_3>} is registered in RDFlib and used in the rest of the package. """ if not MyGraph.xml_serializer_registered_3 : from rdflib.plugin import register from rdflib.serializer import Serializer register(_xml_serializer_name, Serializer, "pyRdfa.serializers.prettyXMLserializer_3", "PrettyXMLSerializer") MyGraph.xml_serializer_registered_3 = True
def initialize(parameters): # Try to add Neo as a backend for RDFLib try: from rdflib import plugin from rdflib.store import Store import neo4j._rdf # assert that the RDF subsystem is available except: # requirements failed, don't register the hook pass else: # register the hook plugin.register('Neo', Store, 'neo4j._hooks.rdflib', 'NeoRdfStore')
def _register_Turtle_parser_2(self) : """The default Turtle parser of RDFLib 2.X is buggy: some constants, like 'true' or 'false', are not handled. An L{own version<serializers.TurtleSerializer>} is registered in RDFLib and used in the rest of the package. This is not used for RDFLib 3.X. """ if not MyGraph.turtle_parser_registered_2 : from rdflib.plugin import register from rdflib.syntax import parsers register(_turtle_parser_name, parsers.Parser, "RDFClosure.parsers.N3Parser","N3Parser") MyGraph.turtle_parser_registered_2 = True
def buildProvenanceTrail(self): self.log.debug("Loading provenance trail") plugin.register("sparql", query.Processor, "rdfextras.sparql.processor", "Processor") plugin.register("sparql", query.Result, "rdfextras.sparql.query", "SPARQLQueryResult") # self.log.debug(self.g.serialize(format='turtle')) expressions_works = self.g.query( """SELECT DISTINCT ?w ?e WHERE { ?w rdf:type frbr:Work . ?e frbr:realizationOf ?w . ?e provo:wasGeneratedAt ?t . ?t time:inXSDDateTime ?dt . } ORDER BY ?w, ?dt """, initNs=dict( frbr=Namespace("http://purl.org/vocab/frbr/core#"), provo=Namespace("http://www.w3.org/ns/prov-o/"), time=Namespace("http://www.w3.org/2006/time#"), ), ) # self.log.debug(expressions_works.result) for row in expressions_works.result: (work, expression) = row self.trail.setdefault(work, []).append(expression) self.log.debug("Work: %s\nExpression: %s" % (work, expression)) activities = self.g.query( """SELECT DISTINCT ?a WHERE { ?a rdf:type provo:Activity . ?a provo:endedAt ?t . ?t time:inXSDDateTime ?dt . } ORDER BY ?dt """, initNs=dict( frbr=Namespace("http://purl.org/vocab/frbr/core#"), provo=Namespace("http://www.w3.org/ns/prov-o/"), time=Namespace("http://www.w3.org/2006/time#"), ), ) self.log.debug(activities.result) for row in activities.result: self.trail.setdefault(self.PROV["Activity"], []).append(row) self.log.debug("Activity: %s" % (row)) self.log.debug(self.trail) # quit() return
def _register_Turtle_serializer_3(self) : """The default Turtle Serializers of RDFLib 2.X is buggy and not very nice as far as the output is concerned. An L{own version<serializers.TurtleSerializer>} is registered in RDFLib and used in the rest of the package. This is not used for RDFLib 3.X. """ if not MyGraph.turtle_serializer_registered_3 : from rdflib.plugin import register from rdflib.serializer import Serializer register(_turtle_serializer_name, Serializer, "RDFClosure.serializers.TurtleSerializer_3", "TurtleSerializer") MyGraph.turtle_serialzier_registered_3 = True
def _register_Turtle_serializer_2(self) : """The default Turtle Serializers of RDFLib 2.X is buggy and not very nice as far as the output is concerned. An L{own version<serializers.TurtleSerializer>} is registered in RDFLib and used in the rest of the package. This is not used for RDFLib 3.X. """ if not MyGraph.turtle_serializer_registered_2 : from rdflib.plugin import register from rdflib.syntax import serializer, serializers register(_turtle_serializer_name, serializers.Serializer, "pyRdfaExtras.serializers.turtleserializer", "TurtleSerializer") MyGraph.turtle_serialzier_registered_2 = True
def _register_XML_serializer_2(self) : """The default XML Serializer of RDFLib 2.X is buggy, mainly when handling lists. An L{own version<serializers.prettyXMLserializer>} is registered in RDFlib and used in the rest of the package. This is not used for RDFLib 3.X. """ if not MyGraph.xml_serializer_registered_2 : from rdflib.plugin import register from rdflib.syntax import serializer, serializers register(_xml_serializer_name, serializers.Serializer, "pyRdfaExtras.serializers.prettyXMLserializer", "PrettyXMLSerializer") MyGraph.xml_serializer_registered_2 = True
def test_jsonld(): # generate shared canvase json-ld tei_file = "../../data/tei/ox/ox-frankenstein_notebook_c1.xml" manifest_uri = 'http://example.com/frankenstein.json' m = Manifest(tei_file, manifest_uri) jsonld = m.jsonld() # parse the json-ld as rdf register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser') g = ConjunctiveGraph() g.parse(data=jsonld, format='json-ld') # sanity check the graph assert g.value(URIRef('http://example.com/frankenstein.json'), RDF.type) == URIRef('http://www.shared-canvas.org/ns/Manifest')
def test_jsonld(): # generate shared canvase json-ld tei_file = "sga/data/tei/ox/ox-frankenstein_notebook_c1.xml" manifest_uri = 'http://example.com/frankenstein.json' m = Manifest(tei_file, manifest_uri) jsonld = m.jsonld() open('test.jsonld', 'w').write(json.dumps(jsonld, indent=2)) # find the manifest manifest = None for r in jsonld['@graph']: if '@type' in r and r['@type'] == 'sc:Manifest': manifest = r assert manifest # check for images assert 'images' in manifest # check for canvases assert 'canvases' in manifest # get the sequence assert 'sequences' in manifest seq = get(jsonld, manifest['sequences'][0]) # first canvas assert 'first' in seq canvas = get(jsonld, seq['first']) assert canvas['label'] == '1r' # check the content annotations assert count_type(jsonld, 'sc:ContentAnnotation') == 90 # css should be there assert count_type(jsonld, 'cnt:ContentAsText') == 61 # parse the json-ld as rdf register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser') g = ConjunctiveGraph() jsonld_str = json.dumps(jsonld) g.parse(data=jsonld_str, format='json-ld') # quick sanity check the graph assert g.value(URIRef('http://example.com/frankenstein.json'), RDF.type) == URIRef('http://www.shared-canvas.org/ns/Manifest') line_anns = list(g.triples((None, RDF.type, SGA.LineAnnotation))) assert len(line_anns) == 638
def __init__(self, directory, config, level = logging.DEBUG): """TabLinker constructor Keyword arguments: directory -- String containing the name turtle file config -- Configuration object, loaded from .ini file level -- A logging level as defined in the logging module """ self.config = config self.log = logging.getLogger("TabLinker") self.log.setLevel(level) self.graph = ConjunctiveGraph() self.log.debug('Loading and parsing file') self.graph.parse(filename, format=config.get('general', 'format')) plugin.register('sparql', rdflib.query.Processor,'rdfextras.sparql.processor', 'Processor') plugin.register('sparql', rdflib.query.Result,'rdfextras.sparql.query', 'SPARQLQueryResult')
def setUp(self): register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser') # self.graph = Graph() self.proj_context_uri = 'http://127.0.0.1:8000/contexts/projects/3.json' self.context_file = settings.STATIC_IMPORTS_ROOT + '3-context.json' self.data_file = settings.STATIC_IMPORTS_ROOT + 'dt-bone.json' self.context_str = self.request_json_str(self.proj_context_uri) self.data_str = self.load_json_file_str(self.data_file) g_context = ConjunctiveGraph(identifier=self.proj_context_uri) g_context.parse(data=self.context_str, format='json-ld') proj_graph_obj = URIRef(self.proj_context_uri) print('N3: ' + str(g_context.__str__())) for c in g_context.contexts(): print(str(c)) print('-------Triples for context-graph------') self.test_type_linking(g_context) g_data = ConjunctiveGraph().parse(data=self.data_str, format='json-ld') print('-------Triples for data-record--------') self.test_type_linking(g_data)
import rdflib from rdflib import Graph, OWL, RDF, RDFS, XSD # Enable SPARQL query from rdflib import plugin plugin.register( 'sparql', rdflib.query.Processor, 'rdfextras.sparql.processor', 'Processor') plugin.register( 'sparql', rdflib.query.Result, 'rdfextras.sparql.query', 'SPARQLQueryResult') class OntologyAnalyzer: """ """ def __init__(self, ontology, opts = {}): """ ontology -- File name of the ontology to analyze """ if not ontology: raise ValueError self.graph = Graph() self.graph.load(ontology) # Bind default NS to prefix on graph self.graph.bind('owl', OWL) self.graph.bind('rdf', RDF) self.graph.bind('rdfs', RDFS) self.graph.bind('xsd', XSD)
from typing import Any, Dict, List, Mapping, MutableSequence, Optional, Union, cast from urllib.parse import urlparse import pkg_resources # part of setuptools from rdflib.parser import Parser from rdflib.plugin import register from ruamel.yaml.comments import CommentedMap, CommentedSeq from . import codegen, jsonld_context, schema from .avro.schema import SchemaParseException from .exceptions import ValidationException, to_one_line_messages from .makedoc import makedoc from .ref_resolver import Loader, file_uri from .utils import json_dumps register("json-ld", Parser, "rdflib_jsonld.parser", "JsonLDParser") _logger = logging.getLogger("salad") def printrdf( workflow: str, wf: Union[CommentedMap, CommentedSeq], ctx: Dict[str, Any], sr: str, ) -> None: g = jsonld_context.makerdf(workflow, wf, ctx) print(g.serialize(format=sr, encoding="utf-8").decode("utf-8")) def main(argsl: Optional[List[str]] = None) -> int: if argsl is None:
# -*- coding: UTF-8 -*- import re import json import itertools from rdflib import Graph from rdflib.plugin import register, Serializer register("json-ld", Serializer, "rdflib.plugins.serializers.jsonld", "JsonLDSerializer") cases = [] def case(*args): cases.append(args) case( """ @prefix dc: <http://purl.org/dc/terms/> . <http://example.org/> dc:title "Homepage"@en . """, { "@context": {"@vocab": "http://purl.org/dc/terms/", "@language": "en"}, "@id": "http://example.org/", "title": "Homepage", }, )
from os import path from rdflib import ConjunctiveGraph, URIRef, Literal from rdflib.namespace import Namespace, RDF, RDFS, DCTERMS, XSD from rdflib.plugin import register, Serializer from ConfigParser import SafeConfigParser from datetime import datetime from urllib2 import urlparse # rdflib-jsonld module required register('application/ld+json', Serializer, 'rdflib_jsonld.serializer', 'JsonLDSerializer') # default metadata config file _CONFIG_FILE = path.join(path.dirname(__file__), 'metadata.ini') # define additional namespaces DCAT = Namespace('http://www.w3.org/ns/dcat#') LANG = Namespace('http://id.loc.gov/vocabulary/iso639-1/') DBPEDIA = Namespace('http://dbpedia.org/resource/') #SPARQLSD = Namespace('http://www.w3.org/ns/sparql-service-description#') # define which sections/fields in the metadata config file are mandatory _CORE_META = ['title', 'publisher', 'version', 'issued', 'modified'] _REQUIRED_META = dict(fdp=_CORE_META + ['fdp_id', 'catalog_id'], catalog=_CORE_META + ['dataset_id', 'theme_taxonomy'], dataset=_CORE_META + ['distribution_id', 'theme'], distribution=_CORE_META + ['access_url|download_url', 'media_type', 'license']) # mappings between fields in the config file and ontologies/vocabularies and data types _ONTO_MAP = dict(fdp_id=[(DCTERMS.identifier, XSD.string)],
""" RDFlib Store implementation for Django, providing lots of extra goodies. Use this application by just including it in your INSTALLED_APPS. After this, you can create a new Graph using: >>> import rdflib >>> g = rdflib.Graph('Django') """ from rdflib.plugin import register from rdflib.store import Store register('Django', Store, 'rdflib_django.store', 'DjangoStore')
def initialize(args): """Build all needed objects. Returns: A dictionary containing the store object and git repo object. """ if args['verbose']: ch.setLevel(logging.ERROR - args['verbose'] * 10) logger.addHandler(ch) logger.debug("Parsed args: {}".format(args)) # add the handlers to the logger if args['logfile']: try: fh = logging.FileHandler(args['logfile']) fh.setLevel(logging.DEBUG) fh.setFormatter(formatter) logger.addHandler(fh) logger.debug("Logfile: {}".format(args['logfile'])) except FileNotFoundError: logger.error("Logfile not found: {}".format(args['logfile'])) sys.exit('Exiting quit') except PermissionError: logger.error("Can not create logfile: {}".format(args['logfile'])) sys.exit('Exiting quit') # from Github: https://github.com/RDFLib/rdflib/issues/617 # Egregious hack, the SequencePath object doesn't support compare, this implements the __lt__ # method so that algebra.py works on sorting in SPARQL queries on e.g. rdf:List paths def sequencePathCompareLt(self, other): return str(self) < str(other) def sequencePathCompareGt(self, other): return str(self) < str(other) setattr(SequencePath, '__lt__', sequencePathCompareLt) setattr(SequencePath, '__gt__', sequencePathCompareGt) # End egregious hack # To get the best behavior, but still we have https://github.com/RDFLib/rdflib/issues/810 rdflib.plugins.sparql.SPARQL_DEFAULT_GRAPH_UNION = args['defaultgraph_union'] # To disable web access: https://github.com/RDFLib/rdflib/issues/810 rdflib.plugins.sparql.SPARQL_LOAD_GRAPHS = False register( 'sparql', Processor, 'quit.tools.processor', 'SPARQLProcessor') register( 'sparql', UpdateProcessor, 'quit.tools.processor', 'SPARQLUpdateProcessor') register( 'application/x-turtle', Serializer, 'rdflib.plugins.serializers.turtle', 'TurtleSerializer') register( 'application/xml', Serializer, 'rdflib.plugins.serializers.rdfxml', 'XMLSerializer') register( 'application/json', Serializer, 'rdflib_jsonld.serializer', 'JsonLDSerializer') register( 'application/trig', Serializer, 'rdflib.plugins.serializers.trig', 'TrigSerializer') register( 'application/xml', ResultSerializer, 'rdflib.plugins.sparql.results.xmlresults', 'XMLResultSerializer') register( 'application/json', ResultSerializer, 'rdflib.plugins.sparql.results.jsonresults', 'JSONResultSerializer') register( 'html', ResultSerializer, 'quit.plugins.serializers.results.htmlresults', 'HTMLResultSerializer') register( 'text/html', ResultSerializer, 'quit.plugins.serializers.results.htmlresults', 'HTMLResultSerializer') register( 'application/xhtml+xml', ResultSerializer, 'quit.plugins.serializers.results.htmlresults', 'HTMLResultSerializer') register( 'text/csv', ResultSerializer, 'rdflib.plugins.sparql.results.csvresults', 'CSVResultSerializer') register( 'application/sparql-results+xml', ResultSerializer, 'rdflib.plugins.sparql.results.xmlresults', 'XMLResultSerializer') register( 'application/sparql-results+json', ResultSerializer, 'rdflib.plugins.sparql.results.jsonresults', 'JSONResultSerializer') try: config = QuitStoreConfiguration( configfile=args['configfile'], targetdir=args['targetdir'], upstream=args['repourl'], features=args['features'], namespace=args['namespace'], oauthclientid=args['oauth_clientid'], oauthclientsecret=args['oauth_clientsecret'], ) except InvalidConfigurationError as e: logger.error(e) sys.exit('Exiting quit') # since repo is handled, we can add graphs to config logger.info('QuitStore Configuration initialized.') logger.debug('Path of Gitrepo: ' + config.getRepoPath()) return config
from rdflib.plugin import register, Parser from rdflib import Graph, ConjunctiveGraph import json register('application/ld+json', Parser, 'rdflib_jsonld.parser', 'JsonLDParser') graph = ConjunctiveGraph() sample_v1 = { "@context": { "organ": "http://purl.obolibrary.org/obo/UBERON_0000062" }, "biomaterial_id": "Specimen_PBMC2", "ncbi_taxon_id": 9606, "organ": "blood" } graph.parse(data=json.dumps(sample_v1), format="json-ld") qres = graph.query( "SELECT ?organ WHERE { ?s <http://purl.obolibrary.org/obo/UBERON_0000062> ?organ}" ) for row in qres: print("%s" % row) graph = ConjunctiveGraph() graph.parse("sample_v2.json", format="json-ld") qres = graph.query(
format = args.format outfile = args.outfile dbpfx = 'sqlite:///' if dburl.startswith(dbpfx) is True: dbfile = dburl.replace(dbpfx, '') if os.path.isfile(dbfile) is False: parser.error("sqlite dbfile '%s' not found" % dbfile) import rdflib as _rdf import sqlalchemy as _sqla from rdb2rdf import * from rdflib.plugin import register, Store # serialize RDF data # Bug: rdb2rdf crashes on MySQL INTEGER data types TINY|SMALL|MEDIUM|BIGINT db = _sqla.create_engine(dburl, echo=False) register('rdb2rdf_dm', Store, 'rdb2rdf.stores', 'DirectMapping') graph = _rdf.Graph('rdb2rdf_dm') graph.open(db) # write RDF into file or STDOUT if outfile is not None: with open(outfile, 'w') as fout: fout.write(graph.serialize(format=format)) else: print(graph.serialize(format=format)) graph.close()
r.addNarrower(animals, mammals) r.addBroader(mammals, animals) r.addHasTopConcept(keyScheme, animals) r.addRelatedMatch(animals, mammals) r.addEditorialNote(animals, 'this is a test') gen = r.getBroader(mammals) for item in gen: if type(item) is URIRef: print 'Concept: ' + item else: print 'Literal language: ' + item.language plugin.register('skos', Serializer, 'skosserializer', 'SKOSSerializer') print r.graph.serialize(format='skos', encoding=r.encoding) for i, j in r.graph.subject_objects(r.osmImplies): print i print j print '\n' r.removeOSMImpliesLiteral(animals, 'blubb') print '\n' for i, j in r.graph.subject_objects(r.osmImplies): print i print j print '\n' '''graph = Graph() g = graph.parse(utils.dataDir() + 'gemet\gemet_concept_en.rdf') for i in g.objects(URIRef('http://www.eionet.europa.eu/gemet/concept/8073'), SKOS.prefLabel):
from rdflib import plugin from rdflib import store # Support execution of nosetests without actual installation plugin.register( 'ZODB', store.Store, 'rdflib_zodb.ZODB', 'ZODBStore')
# # --------------------------------------------------------------------- from rdflib import URIRef from rdflib.plugin import register try: # These moved during the transition from rdflib 2.4 to rdflib 3.0. from rdflib.plugins.serializers.rdfxml import PrettyXMLSerializer # 3.0 from rdflib.serializer import Serializer except ImportError: from rdflib.syntax.serializers.PrettyXMLSerializer import PrettyXMLSerializer # 2.4 from rdflib.syntax.serializers import Serializer class BetterPrettyXMLSerializer(PrettyXMLSerializer): def relativize(self, uri): base = URIRef(self.base) basedir = URIRef( self.base if base.endswith('/') else base.rsplit('/', 1)[0]) if base is not None: if uri == base: uri = URIRef('') elif uri == basedir: uri = URIRef('.') elif uri.startswith(basedir + '/'): uri = URIRef(uri.replace(basedir + '/', "", 1)) return uri register('better-pretty-xml', Serializer, __name__, 'BetterPrettyXMLSerializer')
''' Created on 11/04/2011 @author: acalvo ''' import rdflib from rdflib import Graph, Namespace from rdflib import plugin FOAF = Namespace("http://xmlns.com/foaf/0.1/") RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#") if False: plugin.register('sparql', rdflib.query.Processor, 'rdfextras.sparql.processor', 'Processor') plugin.register('sparql', rdflib.query.Result, 'rdfextras.sparql.query', 'SPARQLQueryResult') my_data = ''' @prefix dc: <http://purl.org/dc/elements/1.1/> . @prefix : <http://example.org/book/> . @prefix ns: <http://example.org/ns#> . :book1 dc:title "SPARQL Tutorial" . :book1 ns:price 42 . :book2 dc:title "The Semantic Web" . :book2 ns:price 23 . ''' g = Graph() g.parse(data=my_data, format="n3") print g.serialize(format='xml')
>>> import rdflib >>> import rdflib_schemaorg_csv >>> g = rdflib.Graph() >>> g.parse("test.csv", format="schemaorg_csv") >>> print g.serialize() """ import csv import StringIO import sys from rdflib import URIRef, Literal, BNode, Namespace, RDF from rdflib.plugin import register from rdflib.parser import Parser register("schemaorg_csv", Parser, "rdflib_schemaorg_csv", "SchemaOrgCSVParser") class SchemaOrgCSVParser(Parser): NAMESPACES = { 'schema' : Namespace('http://schema.org/'), 'scsv' : Namespace('http://purl.org/NET/schema-org-csv#'), 'dcterms' : Namespace('http://purl.org/dc/terms/') } def parse(self, source, sink, **kwargs): """ Pass in a file or file-like object containing CSV with Schema.org column headers and populate the sink graph with triples. """ row_num = 1 fURI = kwargs.get("csv_file_URI", "")
def registerplugins(): """ If rdfextras is installed with setuptools, all plugins are registered through entry_points. This is strongly recommended. If only distutils is available, the plugins must be registed manually This method will register all rdfextras plugins """ from rdflib import plugin from rdflib.query import Processor try: x=plugin.get('sparql',Processor) return # plugins already registered except: pass # must register plugins from rdflib.query import ResultParser, ResultSerializer, Result plugin.register('sparql', Result, 'rdfextras.sparql.query', 'SPARQLQueryResult') plugin.register('sparql', Processor, 'rdfextras.sparql.processor', 'Processor') plugin.register('html', ResultSerializer, 'rdfextras.sparql.results.htmlresults', 'HTMLResultSerializer') plugin.register('xml', ResultSerializer, 'rdfextras.sparql.results.xmlresults', 'XMLResultSerializer') plugin.register('json', ResultSerializer, 'rdfextras.sparql.results.jsonresults', 'JSONResultSerializer') plugin.register('xml', ResultParser, 'rdfextras.sparql.results.xmlresults', 'XMLResultParser') plugin.register('json', ResultParser, 'rdfextras.sparql.results.jsonresults', 'JSONResultParser')
from rdflib.store import Store from rdflib.namespace import RDF, RDFS, SKOS, OWL from urllib import quote from datetime import datetime import re import os import string import requests from linkitup.util import get_qname from linkitup import app from provenance import trail_to_prov # Override RDFLib trig serializer with app/util/trig.py # RDFLib serializer still uses the deprecated '=' between graph URI and graph contents from rdflib.serializer import Serializer plugin.register('trig', Serializer, 'app.util.trig', 'TrigSerializer') LUV = Namespace('http://linkitup.data2semantics.org/vocab/') LU = Namespace('http://linkitup.data2semantics.org/resource/') DBPEDIA = Namespace('http://dbpedia.org/resource/') FOAF = Namespace('http://xmlns.com/foaf/0.1/') DCTERMS = Namespace('http://purl.org/dc/terms/') NANOPUB = Namespace('http://www.nanopub.org/nschema#') PROV = Namespace('http://www.w3.org/ns/prov#') OA = Namespace('http://www.w3.org/ns/oa#') graph_store_endpoint = app.config.get('GRAPH_STORE_ENDPOINT') graph_store_auth_string = app.config.get('GRAPH_STORE_AUTH') if graph_store_auth_string: graph_store_auth = requests.auth.HTTPDigestAuth(*graph_store_auth_string.split(':')) else:
import os import sys import rdflib from enum import Enum from rdflib import plugin from rdflib.serializer import Serializer from rdflib.plugins.memory import IOMemory __author__ = 'Misael Mongiovi, Andrea Giovanni Nuzzolese' plugin.register('application/rdf+xml', Serializer, 'rdflib.plugins.serializers.rdfxml', 'XMLSerializer') plugin.register('xml', Serializer, 'rdflib.plugins.serializers.rdfxml', 'XMLSerializer') class FredType(Enum): Situation = 1 Event = 2 NamedEntity = 3 SkolemizedEntity = 4 Quality = 5 Concept = 6 class NodeType(Enum): Class = 1 Instance = 0 class ResourceType(Enum):
from rdflib import Namespace from rdflib import plugin from rdflib.serializer import Serializer import rdfjson import rdfextras SUPPORTED_OUTPUT_FORMATS = ["rdf-xml", "ttl", "nt", "json", "csv"] NAMESPACES = { 'void' : Namespace('http://rdfs.org/ns/void#'), 'eui' : Namespace('http://institutions.publicdata.eu/#') } # for RDF/JSON output: plugin.register("rdf-json-pretty", Serializer, "rdfjson.RdfJsonSerializer", "PrettyRdfJsonSerializer") # for SPARQL query support: plugin.register('sparql', rdflib.query.Processor, 'rdfextras.sparql.processor', 'Processor') plugin.register('sparql', rdflib.query.Result, 'rdfextras.sparql.query', 'SPARQLQueryResult') class MainHandler(webapp.RequestHandler): def get(self): self.response.out.write(template.render('index.html', None)) class NotFoundHandler(webapp.RequestHandler): def get(self): self.error(404) self.response.out.write(template.render('a404.html', None)) class WellKnownVoIDHandler(webapp.RequestHandler): def get(self):
Project : rdfconvert Description : A little python script that converts files and whole directory trees from one RDF serialization into another. Author : Wim Pessemier Contact : w**.p********@ster.kuleuven.be (replace *) Organization : Institute of Astronomy, KU Leuven """ from rdflib import Graph, plugin from rdflib.parser import Parser from rdflib.serializer import Serializer import sys import os import argparse import fnmatch plugin.register("rdf-json", Parser, "rdflib_rdfjson.rdfjson_parser", "RdfJsonParser") plugin.register("rdf-json", Serializer, "rdflib_rdfjson.rdfjson_serializer", "RdfJsonSerializer") INPUT_FORMAT_TO_EXTENSIONS = { "application/rdf+xml": [".xml", ".rdf", ".owl"], "text/html": [".html"], "xml": [".xml", ".rdf", ".owl"], "rdf-json": [".json"], "json-ld": [".jsonld", ".json-ld"], "ttl": [".ttl"], "nt": [".nt"], "nquads": [".nq"], "trix": [".xml", ".trix"], "rdfa": [".xhtml", ".html"], "n3": [".n3"]
def setUp(self): self.execute('CREATE') plugin.register( 'hstore', Store, 'rdflib_hstore.hstorestore', 'HstoreStore') self.graphs = []
for prefix, namespace in bindings: if (not suppressNamespace) or (not unicode(namespace) in suppressNamespace) :# << Suppress namespaces <<< CHANGE if prefix: write(' xmlns:%s="%s"\n' % (prefix, namespace)) else: write(' xmlns="%s"\n' % namespace) write('>\n') # write out triples by subject for subject in self.store.subjects(): self.subject(subject, 1) # endRDF write("</rdf:RDF>\n") # Set to None so that the memory can get garbage collected. # self.__serialized = None del self._XMLSerializer__serialized register( 'rdf-xml', Serializer, 'RefactorRDF', 'XMLSerializerExtension') if __name__ == '__main__': RefactorRDF()
from rdflib import plugin from rdflib import store plugin.register('SQLAlchemy', store.Store, 'rdflib_sqlalchemy.SQLAlchemy', 'SQLAlchemy')
from rdflib import plugin from rdflib import store import sys # sop to Hudson sys.path.insert(0, '/var/lib/tomcat6/webapps/hudson/jobs/rdfextras') plugin.register('MySQL', store.Store, 'rdflib_mysql.MySQL', 'MySQL')
class TPFStore(Store): def open(self, start_iri, create=False): self.collec = TriplePatternFragment.from_iri(start_iri).dataset def add(self, *triples, context, quoted=False): raise NotImplemented("TPFStore is readonly") def remove(self, *triples, context=None): raise NotImplemented("TPFStore is readonly") def triples(self, triple_pattern, context=None): for triple in self.collec.iter_triples(*triple_pattern): if _triple_match(triple_pattern, triple): yield triple, context def __len__(self, context=None): return self.collec.get_tpf().triple_count def _node_match(template_node, node): return 1 if (template_node is None or template_node == node) else 0 def _triple_match(template_triple, triple): return sum(map(_node_match, template_triple, triple)) == 3 register("TPFStore", Store, "hydra.tpf", "TPFStore")
from rdflib import plugin from rdflib import store from rdflib import query #from .test_context import ContextTestCase #from .test_graph import GraphTestCase import sys # sop to Hudson sys.path.insert(0, '/var/lib/tomcat6/webapps/hudson/jobs/rdfextras') plugin.register( 'sparql', query.Processor, 'rdfextras.sparql.processor', 'Processor') plugin.register( 'sparql', query.Result, 'rdfextras.sparql.query', 'SPARQLQueryResult') plugin.register( 'BerkeleyDB', store.Store, 'rdfextras.store.BerkeleyDB', 'BerkeleyDB') plugin.register( 'BDBOptimized', store.Store, 'rdfextras.store.BDBOptimized', 'BDBOptimized') plugin.register( 'SPARQL', store.Store, 'rdfextras.store.SPARQL', 'SPARQLStore') # SQLObject schemes # scheme://[user[:password]@]host[:port]/database[?parameters]
from django.core.exceptions import PermissionDenied from tardis.tardis_portal.auth import decorators as authz from tardis.tardis_portal.models import \ Experiment, Schema from tardis.tardis_portal.shortcuts import render_response_index, \ return_response_error, return_response_not_found, \ RestfulExperimentParameterSet from .forms import FoRCodeForm SCHEMA_URI = 'http://purl.org/asc/1297.0/2008/for/' PARAMETER_NAMES = FoRCodeForm().fields.keys() plugin.register('application/octet-stream', Parser, 'rdflib.plugins.parsers.notation3', 'N3Parser') logger = logging.getLogger(__name__) for_graph = Graph() try: for_graph.parse(SCHEMA_URI) except (urllib.error.URLError, SocketError): logger.debug('no data connection to get external schema definition') def _get_schema_func(schema_uri): def get_schema(): try: return Schema.objects.get(namespace=schema_uri) except Schema.DoesNotExist:
import rdflib import validator import jsonld from rdflib import Graph, plugin from rdflib.serializer import Serializer from rdflib.parser import Parser plugin.register('json-ld', Serializer, 'rdflib_jsonld.serializer', 'JsonLDSerializer') plugin.register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser') #import rdfextras #rdfextras.registerplugins() # if no setuptools from contextlib import closing from urllib2 import urlopen import html5lib import json import logging import re context = { "@vocab": "http://schema.org/", "http://schema.org/url": { "@type": "@id" },
from rdflib.plugin import register, Serializer register('json-ld', Serializer, 'rdflib_jsonld.serializer', 'JsonLDSerializer') from SPARQLWrapper import SPARQLWrapper, JSON import requests import urllib.parse import json import time def dbpediaSpotlight(text): subjects = [] #* data= urllib.parse.urlencode({'text' : text,'confidence':'0.5', 'types' : 'DBpedia:Event, DBpedia:Food, DBpedia:Name, DBpedia:Person, DBpedia:Place, DBpedia:Work'}) data = data.encode('utf-8') headers = {"Accept": "application/json"} r = requests.post("http://model.dbpedia-spotlight.org/it/annotate", data=data, headers=headers, timeout=50) print ("dbpediaspot: "+r.text) # Convert it to a Python dictionary try: json.loads(r.text) except ValueError: return subjects data = json.loads(r.text)
from nose.exc import SkipTest from rdflib import Literal from rdflib import RDF from rdflib import RDFS from rdflib import URIRef from rdflib import plugin from rdflib import query from rdflib.graph import ConjunctiveGraph from rdflib.graph import Graph from rdflib.graph import ReadOnlyGraphAggregate from rdflib.store import Store from six.moves import cStringIO as StringIO plugin.register("xml", query.ResultParser, "rdflib.plugins.sparql.results.xmlresults", "XMLResultParser") plugin.register("xml", query.ResultSerializer, "rdflib.plugins.sparql.results.xmlresults", "XMLResultSerializer") plugin.register("json", query.ResultParser, "rdflib.plugins.sparql.results.jsonresults", "JSONResultParser") plugin.register("json", query.ResultSerializer, "rdflib.plugins.sparql.results.jsonresults", "JSONResultSerializer") testGraph1N3 = """ @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix : <http://test/> . :foo a rdfs:Class. :bar :d :c. :a :d :c. """
"beginOffset" : { "@id" : "oax:begin" }, "endOffset" : { "@id" : "oax:end" }, "textOffsetSelector" : { "@type" : "@id", "@id" : "oax:TextOffsetSelector" }, "chars" : "cnt:chars", "encoding" : "cnt:characterEncoding", "bytes" : "cnt:bytes", "format" : "dc:format", "language" : "dc:language", "annotatedAt" : "oa:annotatedAt", "serializedAt" : "oa:serializedAt", "when" : "oa:when", "value" : "rdf:value", "start" : "oa:start", "end" : "oa:end", "exact" : "oa:exact", "prefix" : "oa:prefix", "suffix" : "oa:suffix", "label" : "rdfs:label", "name" : "foaf:name", "mbox" : "foaf:mbox" } register('json-ld', Serializer, 'rdflib_jsonld.serializer', 'JsonLDSerializer')
import copy import yaml import pprint import os import json # setup the ontology from smart_common.rdf_tools.rdf_ontology import * from smart_common.rdf_tools.util import bound_graph, URIRef # setup the json-ld serializer import rdflib_jsonld_serializer from rdflib import plugin from rdflib.serializer import Serializer plugin.register('json-ld', Serializer, 'rdflib_jsonld_serializer.jsonld_serializer', 'JsonLDSerializer') f = None try: f = open(os.getcwd()+'/_config.yml').read() except: raise IOError, "Can't read _config.yml" if f != None: config = yaml.load(f) SP_STATMENT = "http://smartplatforms.org/terms#Statement" CONTEXT_URI = config['production_url']+'/reference/data_model/contexts/smart_context.jsonld' # create smart_jsonld_context, copied from smart_sample_apps
directly, since it's a plugin. You'll just want to: >>> import rdflib >>> import rdflib_schemaorg_csv >>> g = rdflib.Graph() >>> g.parse("test.csv", format="schemaorg_csv") >>> print g.serialize() """ import sys import csv import StringIO from rdflib import URIRef, Literal, BNode, Namespace, RDF from rdflib.plugin import register from rdflib.parser import Parser register("schemaorg_csv", Parser, "rdflib_schemaorg_csv", "SchemaOrgCSVParser") class SchemaOrgCSVParser(Parser): NAMESPACES = { "schema": Namespace("http://schema.org/"), "scsv": Namespace("http://purl.org/NET/schema-org-csv#"), "dcterms": Namespace("http://purl.org/dc/terms/"), } def parse(self, source, sink, **kwargs): """ Pass in a file or file-like object containing CSV with Schema.org column headers and populate the sink graph with triples. """ row_num = 1
from rdflib import Graph, util from os import path import requests from rdflib.plugin import register, Serializer from rdflib_jsonld import serializer from docprofiles import PROFILES from docprofile_owlp import Owlp from docprofile_skosp import Skosp register("json-ld", Serializer, "rdflib_jsonld.serializer", "JsonLDSerializer") RDF_FILE_EXTENSIONS = [".rdf", ".owl", ".ttl", ".n3", ".nt", ".json"] RDF_SERIALIZER_MAP = { "text/turtle": "turtle", "text/n3": "n3", "application/n-triples": "nt", "application/ld+json": "json-ld", "application/rdf+xml": "xml", # Some common but incorrect mimetypes "application/rdf": "xml", "application/rdf xml": "xml", "application/json": "json-ld", "application/ld json": "json-ld", "text/ttl": "turtle", "text/turtle;charset=UTF-8": "turtle", "text/ntriples": "nt", "text/n-triples": "nt", "text/plain": "nt", # text/plain is the old/deprecated mimetype for n-triples }
from os import path from rdflib import Graph from rdflib.compare import graph_diff from rdflib.plugin import register, Parser from myglobals import (BASE_URL, DUMP_DIR, MIME_TYPES, URL_PATHS) import six if six.PY2: from urllib2 import (urlopen, urlparse, Request) urljoin = urlparse.urljoin else: from urllib.parse import urljoin from urllib.request import (Request, urlopen, urlparse) register('application/ld+json', Parser, 'rdflib_jsonld.parser', 'JsonLDParser') URLs = [urljoin(BASE_URL, p) for p in URL_PATHS] g_fdp = Graph() # FDP metadata upon HTTP request g_dump = Graph() # reference metadata from dump file def test_compare_triple_counts(): for mime, fext in MIME_TYPES.items(): dump_path = path.join(DUMP_DIR, path.basename(mime)) for url in URLs: if six.PY2: fname = '%s.%s' % (path.basename(urlparse.urlparse(url).path), fext) else: fname = '%s.%s' % (path.basename(urlparse(url).path), fext)
from typing import Any, Dict, List, Union, Text from rdflib import Graph, plugin from rdflib.serializer import Serializer from . import schema from . import jsonld_context from . import makedoc from . import validate from .sourceline import strip_dup_lineno from .ref_resolver import Loader, file_uri _logger = logging.getLogger("salad") from rdflib.plugin import register, Parser register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser') def printrdf(workflow, # type: str wf, # type: Union[List[Dict[Text, Any]], Dict[Text, Any]] ctx, # type: Dict[Text, Any] sr # type: str ): # type: (...) -> None g = jsonld_context.makerdf(workflow, wf, ctx) print(g.serialize(format=sr)) def main(argsl=None): # type: (List[str]) -> int if argsl is None: argsl = sys.argv[1:]
from rdflib import Graph, plugin, Namespace from rdflib.parser import Parser from rdflib.serializer import Serializer plugin.register("rdf-json", Parser, "rdflib_rdfjson.rdfjson_parser", "RdfJsonParser") plugin.register("rdf-json", Serializer, "rdflib_rdfjson.rdfjson_serializer", "RdfJsonSerializer") plugin.register("rdf-json-pretty", Serializer, "rdflib_rdfjson.rdfjson_serializer", "PrettyRdfJsonSerializer") testrdfjson = '''{ "http://example.org/about" : { "http://purl.org/dc/elements/1.1/title": [ { "type" : "literal" , "value" : "Anna's Homepage." } ] } }''' g = Graph() g.bind("dc", "http://purl.org/dc/elements/1.1/") g.parse(data=testrdfjson, format="rdf-json") rdfxml = g.serialize(format="xml") assert '''Anna's Homepage''' in rdfxml print(rdfxml) print("""<?xml version="1.0" encoding="UTF-8"?>
from rdflib.plugin import register, Serializer, Parser # adding namespaces dcat = Namespace("http://www.w3.org/ns/dcat#") res = Namespace("http://purl.org/obs/resource#") obs = Namespace("http://purl.org/obs#") # Logging Configuration logging.basicConfig(filename='logger.log', level=logging.DEBUG, format="%(message)s") logger = logging.getLogger("observer") logger.setLevel(logging.DEBUG) # Registering Parsers register('text/rdf+n3', Parser, 'rdflib.plugins.parsers.notation3', 'N3Parser') register('n3', Parser, 'rdflib.plugins.parsers.notation3', 'N3Parser') register('nquads', Parser, 'rdflib.plugins.parsers.nquads', 'NQuadsParser') register('nt', Parser, 'rdflib.plugins.parsers.nt', 'NTParser') register('trix', Parser,'rdflib.plugins.parsers.trix', 'TriXParser') register('application/rdf+xml', Parser, 'rdflib.plugins.parsers.rdfxml', 'RDFXMLParser') register('xml', Parser, 'rdflib.plugins.parsers.rdfxml', 'RDFXMLParser') register('rdfa', Parser, 'rdflib.plugins.parsers.rdfa', 'RDFaParser') register('text/html', Parser, 'rdflib.plugins.parsers.rdfa', 'RDFaParser') register('application/xhtml+xml', Parser,'rdflib.plugins.parsers.rdfa', 'RDFaParser') register('text/plain', Parser, 'rdflib.plugins.parsers.notation3', 'N3Parser') register('application/octet-stream', Parser, 'rdflib.plugins.parsers.notation3', 'N3Parser') # Constants SPARQL_FORMAT_TAG = [