def __init__(self, repository, cat='default', new=False): # Supply the repository name # Load the configuration, we need the allegrograph connection information if os.path.isfile('/opt/peoplesparql/config.py'): logger.info("INFO connect.py - loaded production config") app.config.from_pyfile('/opt/peoplesparql/config.py', silent=False) else: logger.info("INFO connect.py - loaded local config") app.config.from_object('peoplesparql') logger.info('INFO connect.py - attempting connection to %s', repository) try: server = AllegroGraphServer(app.config['AG_HOST'], app.config['AG_PORT'], app.config['AG_USER'], app.config['AG_PASSWORD']) # public_catalog is default; supply a catalog value to use a different catalogue if cat == 'default': self.catalog = server.openCatalog(app.config['AG_CATALOG']) else: self.catalog = server.openCatalog(cat) self.accessMode = Repository.ACCESS # default is to use an existing repository if not new: self.repo = self.catalog.getRepository(repository, self.accessMode) # if new is true, create a new repository (if it already exists, request is ignored and existing repo used) else: self.repo = self.catalog.createRepository(repository) self.repo = self.catalog.getRepository(repository, self.accessMode) logger.info('INFO connect.py - connected to %s', self.reponame()) except Exception as e: logger.error('ERROR! connect.py 1 - ' + e.message)
def abreRespositorio(self, accessMode=Repository.RENEW): """ Tests getting the repository up. Is called by the other examples to do the startup. """ print "Starting example1()." print "Default working directory is '%s'" % (CURRENT_DIRECTORY) server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD) print "Available catalogs", server.listCatalogs() ## catalog = server.openCatalog(AG_CATALOG) ## named catalog catalog = server.openCatalog() ## default rootCatalog print "Available repositories in catalog '%s': %s" % (catalog.getName(), catalog.listRepositories()) myRepository = catalog.getRepository(AG_REPOSITORY, accessMode) myRepository.initialize() conn = myRepository.getConnection() print "Repository %s is up! It contains %i statements." % ( myRepository.getDatabaseName(), conn.size()) indices = conn.listValidIndices() print "All valid triple indices: %s" % (indices) indices = conn.listIndices() print "Current triple indices: %s" % (indices) print "Removing graph indices..." conn.dropIndex("gospi") conn.dropIndex("gposi") conn.dropIndex("gspoi") indices = conn.listIndices() print "Current triple indices: %s" % (indices) print "Adding one graph index back in..." conn.addIndex("gspoi") indices = conn.listIndices() print "Current triple indices: %s" % (indices) return conn
def getConexao(self, accessMode=Repository.RENEW): server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD) catalog = server.openCatalog() myRepository = catalog.getRepository(AG_REPOSITORY, accessMode) myRepository.initialize() conn = myRepository.getConnection() return conn
def open_connection(self): server = AllegroGraphServer(host=self.host, port=self.port, user=self.user, password=self.password) self.catalog = server.openCatalog('') return (self.catalog.listRepositories())
def main(data): """ Repositories: o2o Subrepositories: ele, ... @return: (FLAG, DATA). (0, dealers) | (1, quality_products) """ # connect to repostry and initial server = AllegroGraphServer(host='localhost', port=10035, user='******', password='******') repos = server.openCatalog().getRepository('o2o', Repository.OPEN) conn = repos.getConnection() # set default namespace for ns,uri in namespaces.iteritems(): conn.setNamespace(ns, uri) try: prds = QualityData(conn, data) if prds: return (0, prds) else: dl = Products(conn, data) return (1, dl) finally: conn.close()
def getConn(repo=MAIN_TARGET_REPO, accessMode=Repository.OPEN): server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD) catalog = server.openCatalog() myRepository = catalog.getRepository(repo, accessMode) myRepository.initialize() conn = myRepository.getConnection() return conn
def connect(repo): server = AllegroGraphServer('172.16.2.21', user='******', password=os.environ['AG_PASSWORD']) catalog = server.openCatalog('zhishime') myRepository = catalog.getRepository(repo, Repository.OPEN) myRepository.initialize() log("Repository %s is up!" % (myRepository.getDatabaseName(), )) return Server(myRepository)
def open_connection(self, repo): server = AllegroGraphServer(host=self.host, port=self.port, user=self.user, password=self.password) catalog = server.openCatalog('') mode = Repository.OPEN repository = catalog.getRepository(repo, mode) conn = repository.getConnection() return [repository, conn]
def getConnection(host, port, user, password, repository): try: server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD) server = AllegroGraphServer(host, port, user, password) catalog = server.openCatalog() myRepository = catalog.getRepository(repository, Repository.ACCESS) connection = myRepository.getConnection() except: e = sys.exc_info()[0] print ("Error: %s" % e) return connection
def iter_conn(fprot,fhet,is_mod = False): server = AllegroGraphServer(host = "http://tabiteuea.lodac.nii.ac.jp", port=10035) catalog = server.openCatalog(None) plbsp = catalog.getRepository("PLBSP_residue" ,"Repository.OPEN") conn = plbsp.getConnection() # Response is Dictionary that have two keys as "names" and "values". # "names" is record name. ?conn ?seq1 [res1, ch1, seq2, res2, ch2, dist, type] in this program's query # "values" is 2dimensional list. this list contain all records by Query. resp = conn.prepareTupleQuery("SPARQL", make_QUERY(fprot,fhet,is_mod)) result = resp.evaluate_generic_query() keys = result["names"] for values in result["values"]: yield {k:v.strip('"') for k,v in zip(keys,values)} conn.close()
def open_connection(self, repo): """ Opens the connection to allegro server connects to the repository passed as an argument """ server = AllegroGraphServer(host=self.host, port=self.port, user=self.user, password=self.password) catalog = server.openCatalog('') mode = Repository.OPEN repository = catalog.getRepository(repo, mode) conn = repository.getConnection() return [repository, conn]
def get(self): available = False try: server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD) catalog = server.openCatalog('') if len(catalog.listRepositories()): available = True except Exception: available = False return available
def getConnection(accessMode=Repository.ACCESS): print "getConnection" print "Default working directory is '%s'" % (CURRENT_DIRECTORY) server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD) print "Available catalogs", server.listCatalogs() catalog = server.openCatalog() print "Available repositories in catalog '%s': %s" % (catalog.getName(), catalog.listRepositories()) myRepository = catalog.getRepository(AG_REPOSITORY, accessMode) conn = myRepository.getConnection() print "Repository %s is up! It contains %i statements." % ( myRepository.getDatabaseName(), conn.size()) indices = conn.listValidIndices() print "All valid triple indices: %s" % (indices) indices = conn.listIndices() print "Current triple indices: %s" % (indices) return conn
def getServerConnection(accessMode): # For remote linux server, using port forwarding from localhost. #server = AllegroGraphServer("localhost", port=AG_PORT, user="******", password="******") # For localhost. # Get a server object. server = AllegroGraphServer("localhost", port=AG_PORT) # Get a catalog object. catalog = server.openCatalog('scratch') # Create a new or access an existing repository and get a connection object. myRepository = catalog.getRepository("kast_data", accessMode) myRepository.initialize() connection = myRepository.getConnection() # Return the connection object. return connection
def GetConn(name, if_return_repo=False): AGRAPH_HOST = os.environ.get('AGRAPH_HOST') AGRAPH_PORT = int(os.environ.get('AGRAPH_PORT', '10035')) server = AllegroGraphServer(AGRAPH_HOST, AGRAPH_PORT, 'bubble', 'bubble') catalog = server.openCatalog('') # get repo_names repo_names = [] for repo_name in catalog.listRepositories(): repo_names.append(repo_name) if name in repo_names: mode = Repository.OPEN my_repository = catalog.getRepository(name, mode) conn = my_repository.getConnection() else: print('%s repo do not exist !' % name) if if_return_repo: return conn, my_repository else: return conn
def connect_to_kabob(self): self.log.debug("Connecting to AllegroGraph server --" + "host:'%s' port:%s" % (KaBOB_Constants.HOST, KaBOB_Constants.PORT)) kabob_server = AllegroGraphServer(KaBOB_Constants.HOST, KaBOB_Constants.PORT, KaBOB_Constants.USER, KaBOB_Constants.PASSWORD) if KaBOB_Constants.CATALOG in kabob_server.listCatalogs( ) or KaBOB_Constants.CATALOG == '': kabob_catalog = kabob_server.openCatalog(KaBOB_Constants.CATALOG) if KaBOB_Constants.RELEASE in kabob_catalog.listRepositories(): mode = Repository.OPEN self.kabob_repository = kabob_catalog.getRepository( KaBOB_Constants.RELEASE, mode) self.kabob = self.kabob_repository.getConnection() # print('Repository %s is up!' % self.kabob_repository.getDatabaseName()) # print('It contains %d statement(s).' % self.kabob.size()) else: print('%s does not exist' % KaBOB_Constants.RELEASE) print("Available repositories in catalog '%s':" % kabob_catalog.getName()) for repo_name in kabob_catalog.listRepositories(): print(' - ' + repo_name) else: print('%s does not exist' % KaBOB_Constants.CATALOG) print('Available catalogs:') for cat_name in kabob_server.listCatalogs(): if cat_name is None: print(' - <root catalog>') else: print(' - ' + str(cat_name))
def establish_connection(self): try: server = AllegroGraphServer(host='192.168.1.27', port=10035, user=self.username, password=self.password) catalog = server.openCatalog(None) except RequestError: print("Please run the script again.") exit() repository = None try: repository = catalog.getRepository(self.repository, Repository.OPEN) except ServerException: print("No repository found. Creating repository...") #creating repository if Allegro doesn't have it. repository_name = input( "Enter the name of Repository. (Enter 'y' for DailyNewsEngine)" ) if repository_name == 'y': repository_name = 'DailyNewsEngine' self.repository = repository_name catalog.createRepository(repository_name) repository = catalog.getRepository(self.repository, Repository.OPEN) if repository != None: repository = repository.initialize() connection = repository.getConnection() self.connection = connection return { 'server': server, 'catalog': catalog, 'repository': repository, 'connection': connection }
class WriterPlugin(RDFWriter): def __init__(self, reader, *args, **kwargs): RDFWriter.__init__(self, reader, *args, **kwargs) if isinstance(self.reader, ReaderPlugin): self.__server = self.reader.server self.__port = self.reader.port self.__catalog = self.reader.catalog self.__repository = self.reader.repository self.__allegro_server = self.reader.allegro_server self.__allegro_catalog = self.reader.allegro_catalog self.__allegro_repository = self.reader.allegro_repository else: self.__server = kwargs["server"] if "server" in kwargs else "localhost" self.__port = kwargs["port"] if "port" in kwargs else 6789 self.__catalog = kwargs["catalog"] if "catalog" in kwargs else None self.__repository = kwargs["repository"] if "repository" in kwargs else None if not self.__catalog or not self.__repository: raise Exception("Must specify the <catalog> and the <repository> arguments") self.__allegro_server = AllegroGraphServer(self.__server, port=self.__port) self.__allegro_catalog = self.__allegro_server.openCatalog(self.__catalog) self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS) self.__allegro_repository.initialize() self.__con = self.__allegro_repository.getConnection() self.__f = self.__allegro_repository.getValueFactory() results_format = property(lambda self: "json") server = property(lambda self: self.__server) port = property(lambda self: self.__port) catalog = property(lambda self: self.__catalog) repository = property(lambda self: self.__repository) allegro_server = property(lambda self: self.__allegro_server) allegro_catalog = property(lambda self: self.__allegro_catalog) allegro_repository = property(lambda self: self.__allegro_repository) def _save(self, *resources): for resource in resources: s = resource.subject self.__remove(s, context=resource.context) for p, objs in resource.rdf_direct.items(): for o in objs: self.__add(s, p, o, resource.context) def _update(self, *resources): for resource in resources: s = resource.subject for p in resource.rdf_direct: self.__remove(s, p, context=resource.context) for p, objs in resource.rdf_direct.items(): for o in objs: self.__add(s, p, o, resource.context) def _remove(self, *resources, **kwargs): inverse = kwargs.get("inverse") for resource in resources: self.__remove(s=resource.subject, context=resource.context) if inverse: self.__remove(o=resource.subject, context=resource.context) def _size(self): return self.__con.size() def _add_triple(self, s=None, p=None, o=None, context=None): self.__add(s, p, o, context) def _set_triple(self, s=None, p=None, o=None, context=None): self.__remove(s, p, context=context) self.__add(s, p, o, context) def _remove_triple(self, s=None, p=None, o=None, context=None): self.__remove(s, p, o, context) # used by the sesame api def __add(self, s=None, p=None, o=None, context=None): self.log.info("ADD TRIPLE: %s, %s, %s, %s" % (s, p, o, context)) self.__con.addTriple( toSesame(s, self.__f), toSesame(p, self.__f), toSesame(o, self.__f), contexts=toSesame(context, self.__f) ) def __remove(self, s=None, p=None, o=None, context=None): self.log.info("REM TRIPLE: %s, %s, %s, %s" % (s, p, o, context)) self.__con.removeTriples( toSesame(s, self.__f), toSesame(p, self.__f), toSesame(o, self.__f), contexts=toSesame(context, self.__f) ) def index_triples(self, **kwargs): """ Index triples if this functionality is present. Return `True` if successful. """ all = kwargs["all"] if "all" in kwargs else False asynchronous = kwargs["asynchronous"] if "asynchronous" in kwargs else False self.__allegro_repository.indexTriples(all=all, asynchronous=asynchronous) return True def load_triples(self, **kwargs): """ loads triples from supported sources if such functionality is present returns True if operation successfull """ format = kwargs["format"] if "format" in kwargs else RDFFormat.RDFXML format = RDFFormat.NTRIPLES if format is "nt" else RDFFormat.RDFXML source = kwargs["source"] if "source" in kwargs else None base = kwargs["base"] if "base" in kwargs else None context = kwargs["context"] if "context" in kwargs else None server_side = kwargs["server_side"] if "server_side" in kwargs else True if source: self.__con.addFile( source, base=base, format=format, context=toSesame(context, self.__f), serverSide=server_side ) return True return False def _clear(self, context=None): """ Clear the triple-store. """ self.__con.clear(contexts=toSesame(context, self.__f)) # Extra functionality def register_fts_predicate(self, namespace, localname): """ register free text search predicates """ self.__allegro_repository.registerFreeTextPredicate(namespace=unicode(namespace), localname=localname) def namespaces(self): return self.__con.getNamespaces() def namespace(self, prefix): return self.__con.getNamespace(prefix) def set_namespace(self, prefix, namespace): self.__con.setNamespace(prefix, namespace) def remove_namespace(self, prefix): self.__con.removeNamespace(prefix) def clear_namespaces(self): self.__con.clearNamespaces() def close(self): self.__con.close()
class ReaderPlugin(RDFQueryReader): def __init__(self, *args, **kwargs): RDFQueryReader.__init__(self, *args, **kwargs) self.__server = kwargs["server"] if "server" in kwargs else "localhost" self.__port = kwargs["port"] if "port" in kwargs else 6789 self.__user = kwargs["user"] if "user" in kwargs else None self.__password = kwargs["password"] if "password" in kwargs else None self.__catalog = kwargs["catalog"] if "catalog" in kwargs else None self.__repository = kwargs["repository"] if "repository" in kwargs else None if not self.__catalog or not self.__repository: raise Exception("Must specify the <catalog> and the <repository> arguments") self.__allegro_server = AllegroGraphServer( self.__server, port=self.__port, user=self.__user, password=self.__password ) self.__allegro_catalog = self.__allegro_server.openCatalog(self.__catalog) self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS) self.__allegro_repository.initialize() self.__con = self.allegro_repository.getConnection() results_format = property(lambda self: "json") server = property(lambda self: self.__server) port = property(lambda self: self.__port) user = property(lambda self: self.__user) password = property(lambda self: self.__password) catalog = property(lambda self: self.__catalog) repository = property(lambda self: self.__repository) allegro_server = property(lambda self: self.__allegro_server) allegro_catalog = property(lambda self: self.__allegro_catalog) allegro_repository = property(lambda self: self.__allegro_repository) def _to_table(self, result): table = [] bindings = result.getBindingNames() for bindingSet in result: row = {} for key in bindings: try: v = toRdfLib(bindingSet[key]) except: v = None row[key] = v table.append(row) return table def _ask(self, result): """ returns the boolean value of a ASK query """ return result # execute def _execute(self, query): if query.query_type == "select": return self.__execute_select(unicode(query)) elif query.query_type == "ask": return self.__execute_ask(unicode(query)) def __execute_ask(self, q_string): boolQuery = self.__con.prepareBooleanQuery(QueryLanguage.SPARQL, q_string) return boolQuery.evaluate() def __execute_select(self, q_string): self.log.debug(q_string) tupleQuery = self.__con.prepareTupleQuery(QueryLanguage.SPARQL, q_string) tupleQuery.setIncludeInferred(self.inference) return tupleQuery.evaluate() def execute_sparql(self, q_string, format="JSON"): self.log.debug(q_string) tupleQuery = self.__con.prepareQuery(QueryLanguage.SPARQL, q_string) tupleQuery.setIncludeInferred(self.inference) # Do some magic as Franz's API doesn't provide a unified API for # ask & select result = tupleQuery.evaluate_generic_query() if format == "JSON": if type(result) is dict: response = TupleQueryResult(result["names"], result["values"]) return self._results_to_json(response) else: # Build our own JSON response return {"head": {}, "boolean": result} else: return result def close(self): self.__con.close() def _results_to_json(self, results): bindings = results.getBindingNames() r_dict = {} r_dict["head"] = {"vars": bindings} r_dict["results"] = {"bindings": []} for bindingSet in results: json_binding = {} for b in bindings: value = bindingSet.getValue(b) if type(value) is sv.URI: json_binding[b] = {"type": "uri", "value": value.getURI()} elif type(value) is sv.BNode: json_binding[b] = {"type": "bnode", "value": value.getID()} elif type(value) is sl.Literal: dtype = value.getDatatype() if value.getDatatype() else None lang = value.getLanguage() if value.getLanguage() else None lit_type = "typed-literal" if dtype else "literal" json_binding[b] = {"type": lit_type, "value": value.getLabel()} if dtype: if type(dtype) is sv.URI: json_binding[b]["datatype"] = dtype.getURI() elif type(dtype) in [str, unicode] and dtype.startswith("<") and dtype.endswith(">"): json_binding[b]["datatype"] = URIRef(dtype.strip("<>")) else: json_binding[b]["datatype"] = URIRef(dtype) if lang: json_binding[b]["xml:lang"] = lang r_dict["results"]["bindings"].append(json_binding) return r_dict
from server_config import * from franz.openrdf.sail.allegrographserver import AllegroGraphServer from franz.openrdf.repository.repository import Repository import pymysql from segmentation import * from Logger import logger import json from multiprocessing.pool import Pool import time import warnings from collections import defaultdict warnings.filterwarnings("ignore") # connect to Allegrograph server = AllegroGraphServer(**para_agraph) catalog = server.openCatalog("") graph = catalog.getRepository(repository_agraph, Repository.ACCESS) graph.initialize() conn_graph = graph.getConnection() set_keys = { 'abstract', 'category', 'externalLink', # useless 'relatedPage', 'pageDisambiguates', 'internalLink', 'pageRedirects', # 是否要记录下来? 将此项单独放在一个表中 } weight_ld = {'abs': 1, 'pro': 3.1, 'cat': 3.1, 'rel': 2.1, 'ilk': 2.1}
class AG(object): def __init__(self, configFile = None): # Read the AG connection parameters if configFile is None: configFile = defaultConfigFile self.configFile = configFile config = ConfigParser.ConfigParser() config.readfp(open(configFile)) ag_params = dict(config.items("ag")) # Connect to the server self.server = AllegroGraphServer(ag_params['ag_host'], int(ag_params['ag_port']), ag_params['ag_user'], ag_params['ag_pass']) # Open the 'None' catalog self.catalog = self.server.openCatalog(ag_params['ag_catalog']) print "Available repositories in catalog '%s': %s" % (self.catalog.getName(), self.catalog.listRepositories()) # Get a repository self.myRepository = self.catalog.getRepository(ag_params['ag_repository'], Repository.ACCESS).initialize() #myRepository.initialize() # initialize it # Connect to repository self.conn = self.myRepository.getConnection() print "Repository %s is up! It contains %i statements." % (self.myRepository.getDatabaseName(), self.conn.size()) # Check whether we have the requisite namespaces self.namespaces = self.conn.getNamespaces() if MC_NS_ABBREV not in self.namespaces.keys(): self.conn.setNamespace(MC_NS_ABBREV, MC_NS) if MCO_NS_ABBREV not in self.namespaces.keys(): self.conn.setNamespace(MCO_NS_ABBREV, MCO_NS) for ns in otherNamespaces: if MC_NS_ABBREV+ns not in self.namespaces.keys(): self.conn.setNamespace(MC_NS_ABBREV+ns, MC_NS+ns+"/") self.namespaces = self.conn.getNamespaces() def initializeRepository(self): self.myRepository.initialize() def closeRepository(self): self.myRepository.shutDown() def addToRepository(self,stmts): if not(type(stmts) == list): stmts = [stmts] for stmt in stmts: # Check to see whether the statement already exists in the database cntxt = stmt[3] if len(stmt)>3 else None #pdb.set_trace() existing = self.conn.getStatements(stmt[0], stmt[1], stmt[2], contexts=cntxt) if len(existing) == 0: self.conn.addTriple(stmt[0], stmt[1], stmt[2], contexts=cntxt) def generateContextIDs(self): # Get namespace contexts that ultimately serve unique identifiers for people, music, and memories mc = self.namespaces[MC_NS_ABBREV] self.contextURIs = { 'person': self.conn.createURI(mc+'person'), 'memory': self.conn.createURI(mc+'memory'), 'music': self.conn.createURI(mc+'music')} self.contextStrs = { 'person': mc+'person/', 'memory': mc+'memory/', 'music': mc+'music/'} # if there is a preloaded ontology generated by other means, e.g. in Protege, we can fetch the relevant entities by their labels def fetchOntology(self): self.onto = {} # Fetch all classes that have a label self.onto['Classes'] = {} queryString = """ SELECT ?s ?o WHERE { ?s rdfs:label ?o . ?s rdf:type owl:Class . } """ tupleQuery = self.conn.prepareTupleQuery("SPARQL", queryString) result = tupleQuery.evaluate() for bindingSet in result: self.onto['Classes'][bindingSet[1].getValue()] = bindingSet[0] # Fetch all Object properties that have a label self.onto['ObjectProperties'] = {} queryString = """ SELECT ?s ?o WHERE { ?s rdfs:label ?o . ?s rdf:type owl:ObjectProperty . } """ tupleQuery = self.conn.prepareTupleQuery("SPARQL", queryString) result = tupleQuery.evaluate() for bindingSet in result: self.onto['ObjectProperties'][bindingSet[1].getValue()] = bindingSet[0] # Fetch all Data properties that have a label self.onto['DataProperties'] = {} queryString = """ SELECT ?s ?o WHERE { ?s rdfs:label ?o . ?s rdf:type owl:DatatypeProperty . } """ tupleQuery = self.conn.prepareTupleQuery("SPARQL", queryString) result = tupleQuery.evaluate() for bindingSet in result: self.onto['DataProperties'][bindingSet[1].getValue()] = bindingSet[0] self.onto['Descriptions'] = {} queryString = """ SELECT ?s ?o WHERE { ?s rdfs:label ?o . ?s rdf:type mco:Description . } """ tupleQuery = self.conn.prepareTupleQuery("SPARQL", queryString) result = tupleQuery.evaluate() for bindingSet in result: self.onto['Descriptions'][bindingSet[1].getValue()] = bindingSet[0] # Fetch all of the Emotion types that have been declared self.onto['Emotion'] = {} queryString = """ SELECT ?s ?o WHERE { ?s rdfs:label ?o . ?s rdf:type mco:Emotion . } """ tupleQuery = self.conn.prepareTupleQuery("SPARQL", queryString) result = tupleQuery.evaluate() for bindingSet in result: self.onto['Emotion'][bindingSet[1].getValue()] = bindingSet[0] # Fetch all of the Place, Event, Person types that have been declared importClasses = ['PlaceType','PersonType','EventType','EmotionType'] for currClass in importClasses: self.onto[currClass] = {} queryString = """ SELECT ?s ?o WHERE { ?s rdfs:label ?o . ?s rdf:type mco:%s . } """ % (currClass) tupleQuery = self.conn.prepareTupleQuery("SPARQL", queryString) result = tupleQuery.evaluate() for bindingSet in result: self.onto[currClass][bindingSet[1].getValue()] = bindingSet[0] # Fetch all Person definitions (this actually returns all participants. Will need to change this in the future) self.onto['Person'] = {} queryString = """ SELECT ?s ?o WHERE { ?s rdfs:label ?o; rdf:type foaf:Person . } """ tupleQuery = self.conn.prepareTupleQuery("SPARQL", queryString) result = tupleQuery.evaluate() for bindingSet in result: self.onto['Person'][bindingSet[1].getValue()] = bindingSet[0] # Get various response options self.onto['ResponseOptions'] = {} queryString = """ SELECT ?s ?o WHERE { ?s rdfs:label ?o ; rdf:type owl:DatatypeProperty . } """ tupleQuery = self.conn.prepareTupleQuery("SPARQL", queryString) result = tupleQuery.evaluate() for bindingSet in result: self.onto['ResponseOptions'][bindingSet[1].getValue()] = bindingSet[0] # if we are generating the ontology in the repository from this object, then call instantiateOntology def instantiateOntology(self): mco = self.namespaces[MCO_NS_ABBREV] mc = self.namespaces[MC_NS_ABBREV] topObjectPropertyURI = self.conn.createURI(self.namespaces['owl']+'topObjectProperty') topDataPropertyURI = self.conn.createURI(self.namespaces['owl']+'topDataProperty') self.generateContextIDs() # Get various ontology terms that we want to use self.onto = {} self.onto['Classes'] = { 'Person': self.conn.createURI(self.namespaces['foaf']+'Person'), 'Music': self.conn.createURI(mco+'Music'), 'Track': self.conn.createURI(mco+'Track'), 'Memory': self.conn.createURI(mco+'Memory'), 'Description': self.conn.createURI(mco+'Description'), 'Emotion': self.conn.createURI(mco+'Emotion'), 'EventType': self.conn.createURI(mco+'EventType'), 'PlaceType': self.conn.createURI(mco+'PlaceType'), 'PersonType': self.conn.createURI(mco+'PersonType'), 'EmotionType': self.conn.createURI(mco+'EmotionType'), 'SharingProperties': self.conn.createURI(mco+'SharingProperties'), } # Assert the classes as sub-classes of Thing so that we make Protege happy for k,v in self.onto['Classes'].iteritems(): self.addToRepository((v, RDFS.SUBCLASSOF, self.conn.createURI(self.namespaces['owl']+'Thing'))) self.addToRepository((v, RDF.TYPE, self.conn.createURI(self.namespaces['owl']+'Class'))) self.addToRepository((v, RDFS.LABEL, self.conn.createLiteral(k))) self.onto['ObjectProperties'] = {} currStr = "heard" currURI = self.conn.createURI(mco+currStr) self.onto['ObjectProperties'][currStr] = currURI self.addToRepository([ (currURI,OWL.OBJECTPROPERTY, self.onto['Classes']['Person']), (currURI,RDFS.DOMAIN, self.onto['Classes']['Person']), (currURI,RDFS.RANGE, self.onto['Classes']['Music']), (currURI,OWL.INVERSEOF, self.conn.createURI(mco+"heardBy")), (currURI,RDFS.LABEL, self.conn.createLiteral(currStr)), (currURI,RDF.TYPE,OWL.OBJECTPROPERTY)]) currStr = "remembered" currURI = self.conn.createURI(mco+currStr) self.onto['ObjectProperties'][currStr] = currURI self.addToRepository([ (currURI,OWL.OBJECTPROPERTY, self.onto['Classes']['Person']), (currURI,RDFS.DOMAIN, self.onto['Classes']['Person']), (currURI,RDFS.RANGE, self.onto['Classes']['Memory']), (currURI,OWL.INVERSEOF, self.conn.createURI(mco,'rememberedBy')), (currURI,RDFS.LABEL, self.conn.createLiteral(currStr)), (currURI,RDF.TYPE,OWL.OBJECTPROPERTY)]) # Establish equivalence of our Music and Track classes # The idea here is that the Track class is what is also used in Pyjack self.addToRepository((self.onto['Classes']['Music'], OWL.EQUIVALENTCLASS, self.onto['Classes']['Track'])) # Loop over attribute names in Track class and create subPropertyOf definitions as appropriate self.onto['Track'] = {} for k in Track().__dict__.keys(): currSubject = self.conn.createURI(mco+k) self.addToRepository([ (currSubject, RDFS.DOMAIN, self.onto['Classes']['Track']), (currSubject, RDFS.RANGE, RDFS.LITERAL), (currSubject, RDF.TYPE, OWL.OBJECTPROPERTY), (currSubject, RDFS.LABEL, self.conn.createLiteral(k))]) self.onto['Track'][k] = currSubject predicates = ['heardBy','evoked'] for currPred in predicates: currURI = self.conn.createURI(mco+currPred) self.onto['ObjectProperties'][currPred] = currURI # self.onto['Track'][currPred] = currSubject self.addToRepository([ (currURI, RDFS.LABEL, self.conn.createLiteral(currPred)), (currURI, RDF.TYPE,OWL.OBJECTPROPERTY), (currURI, RDFS.DOMAIN, self.onto['Classes']['Music']), ]) if currPred == 'evoked': self.addToRepository((currURI, RDFS.RANGE, self.onto['Classes']['Memory'])) elif currPred == 'heardBy': self.addToRepository((currURI, RDFS.RANGE, self.onto['Classes']['Person'])) # Add categorical type classes # EmotionType and Emotion are largely the same, but both are instantiated to handle differences between data collected via MEAMCentral memory cards and previous Ensemble experiments. Needs to be homogenized at some point. categoricalClasses = ['PersonType','EventType','PlaceType','EmotionType'] for category in categoricalClasses: if category == 'PersonType': m = Person() elif category == 'EventType': m = Event() elif category == 'PlaceType': m = Place() elif category == 'EmotionType': m = Emotion() # Add an empty dict for this category self.onto[category] = {} # Fill the dict for this category for p in m.allowedKeys: # Sanitize our strings p = re.sub('\s','_',p) currSubject = self.conn.createURI(mco+p) self.onto[category][p] = currSubject self.addToRepository([ (currSubject, RDF.TYPE, self.onto['Classes'][category]), (currSubject, RDFS.LABEL, self.conn.createLiteral(p))]) # Generate the MemoryDescription ontology self.onto['Memory'] = {} m = Memory() for p in m.properties: currSubject = self.conn.createURI(mco+p) self.onto['Memory'][p] = currSubject self.addToRepository([ (currSubject, RDFS.DOMAIN, self.onto['Classes']['Memory']), (currSubject, RDFS.LABEL, self.conn.createLiteral(p)), (currSubject, RDF.TYPE, OWL.OBJECTPROPERTY)]) # Specify the range if p == "evokedBy": self.addToRepository([ (currSubject, RDFS.RANGE, self.onto['Classes']['Music']), (currSubject, RDFS.COMMENT, self.conn.createLiteral("Music evokes Memory")), (currSubject, OWL.INVERSEOF, self.onto['ObjectProperties']['evoked'])]) elif p == "rememberedBy": self.addToRepository((currSubject, RDFS.RANGE, self.onto['Classes']['Person'])) elif p == "hasDescription": self.addToRepository((currSubject, RDFS.RANGE, RDFS.LITERAL)) for k in m.allowedKeys: currSubject = self.conn.createURI(mco+k) self.addToRepository([ (currSubject, RDF.TYPE, self.onto['Classes']['Description']), (currSubject, RDFS.LABEL, self.conn.createLiteral(k)), (currSubject, RDF.TYPE, OWL.OBJECTPROPERTY)]) self.onto['Memory'][k] = currSubject # Add predicates associated with analyses of the memory reports currValue = "hasPOSTaggedString" currSubject = self.conn.createURI(mco+currValue) self.addToRepository([ (currSubject, RDF.TYPE, OWL.DATATYPEPROPERTY), (currSubject, RDFS.RANGE, self.namespaces['xsd']+'string'), (currSubject, RDFS.LABEL, currValue), (currSubject, RDFS.COMMENT, "associates a Part-Of-Speech tagged string with a source string")]) currValue = "hasText" currSubject = self.conn.createURI(mco+currValue) self.addToRepository([ (currSubject, RDF.TYPE, OWL.DATATYPEPROPERTY), (currSubject, RDFS.RANGE, self.namespaces['xsd']+'string'), (currSubject, RDFS.LABEL, currValue), (currSubject, RDFS.COMMENT, "used to associate strings with memory description entries")]) # Generate the Emotion ontology self.onto['Emotion'] = {} e = Emotion() for p in e.properties: currSubject = self.conn.createURI(mco+p) self.onto['Emotion'][p] = currSubject self.addToRepository([ (currSubject, RDFS.DOMAIN, self.onto['Classes']['Emotion']), (currSubject, RDF.TYPE, OWL.OBJECTPROPERTY), (currSubject, RDFS.LABEL, self.conn.createLiteral(p))]) for k in e.allowedKeys: currSubject = self.conn.createURI(mco+k) self.addToRepository([ (currSubject, RDF.TYPE, self.onto['Classes']['Emotion']), (currSubject, RDFS.LABEL, self.conn.createLiteral(k))]) self.onto['Emotion'][k] = currSubject # Deal with various response options self.onto['ResponseOptions'] = {} r = ResponseOptions() for k in r.allowedKeys: currSubject = self.conn.createURI(mco+k) self.onto['ResponseOptions'][k] = currSubject self.addToRepository([ (currSubject, RDF.TYPE, OWL.DATATYPEPROPERTY), (currSubject, RDFS.LABEL, self.conn.createLiteral(k))]) # Neurobiography related stuff currStr = "nb_participant" currURI = self.conn.createURI(mco+currStr) self.onto['ObjectProperties'][currStr] = currURI self.addToRepository([ (currURI,OWL.OBJECTPROPERTY, self.onto['Classes']['Person']), (currURI,RDFS.DOMAIN, self.onto['Classes']['Person']), (currURI, RDFS.RANGE, self.namespaces['xsd']+'boolean'), (currURI,RDFS.LABEL, self.conn.createLiteral(currStr)), (currURI,RDF.TYPE,OWL.OBJECTPROPERTY)]) # Sharing properties currClass = 'SharingProperties' self.onto[currClass] = {} currURI = self.conn.createURI(mco+currValue) self.onto['ObjectProperties'][currClass] = currURI triples = [] for p in SharingProperties().properties: currSubject = self.conn.createURI(mco+p) self.onto[currClass][p] = currSubject triples.append((currSubject, OWL.OBJECTPROPERTY, self.onto['Classes'][currClass])) triples.append((currSubject, RDF.TYPE, OWL.OBJECTPROPERTY)) triples.append((currSubject, RDFS.LABEL, self.conn.createLiteral(p))) if p in ['sharedGlobally']: triples.append((currSubject, RDFS.RANGE, self.namespaces['xsd']+'boolean')) # Now add the sharing properties data self.addToRepository(triples) ## ## Various sub-functions to generate RDF constructs ## # Generate a node list def generateCollection(self, *nodeList): triples = [] headNode = self.conn.createBNode() triples.append((headNode, RDF.TYPE, OWL.CLASS)) nextNode = headNode for count, node in enumerate(nodeList): parentNode = nextNode triples.append((parentNode, RDF.FIRST, node)) if count == (len(nodeList)-1): nextNode = RDF.NIL else: nextNode = self.conn.createBNode() triples.append((parentNode, RDF.REST, nextNode)) # Add the triples to the datastore self.addToRepository(triples) return headNode
"host:'%s' port:%s" % (AG_HOST, AG_PORT)) server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD) ################ SHOWING CATALOGS ###################################### print("Available catalogs:") for cat_name in server.listCatalogs(): if cat_name is None: print(' - <root catalog>') else: print(' - ' + str(cat_name)) ################ SHOWING REPOSITORIES ################################## catalog = server.openCatalog('') print("Available repositories in catalog '%s':" % catalog.getName()) for repo_name in catalog.listRepositories(): print(' - ' + repo_name) ################ CREATING REPOSITORY ################################### mode = Repository.ACCESS my_repository = catalog.getRepository('innuendo', mode) my_repository.initialize() conn = my_repository.getConnection() if sys.argv[1] == "backup": outputFile2 = file_path # outputFile2 = None
localNSpace = config["localNSpace"] protocolsTypes = config["protocolsTypes"] processTypes = config["processTypes"] processMessages = config["processMessages"] basedir = config["basedir"] AG_HOST = config["AG_HOST"] AG_PORT = config["AG_PORT"] AG_REPOSITORY = config["AG_REPOSITORY"] AG_USER = config["AG_USER"] AG_PASSWORD = config["AG_PASSWORD"] from queryParse2Json import parseAgraphStatementsRes, parseAgraphQueryRes # setup agraph server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD) catalog = server.openCatalog() # default rootCatalog # print "Available repositories in catalog '%s': %s" % (catalog.getName(), # catalog.listRepositories()) myRepository = catalog.getRepository(AG_REPOSITORY, Repository.OPEN) myRepository.initialize() dbconAg = myRepository.getConnection() dedicateddbconAg = myRepository.getConnection() #print "Repository %s is up! It contains %i statements." % ( # myRepository.getDatabaseName(), dbconAg.size()) #print '####################################################' from franz.openrdf.vocabulary.xmlschema import XMLSchema from franz.openrdf.query.query import QueryLanguage
class ReaderPlugin(RDFQueryReader): def __init__(self, *args, **kwargs): RDFQueryReader.__init__(self, *args, **kwargs) self.__server = kwargs['server'] if 'server' in kwargs else 'localhost' self.__port = kwargs['port'] if 'port' in kwargs else 6789 self.__catalog = kwargs['catalog'] if 'catalog' in kwargs else None self.__repository = kwargs['repository'] if 'repository' in kwargs else None if not self.__catalog or not self.__repository: raise Exception('Must specify the <catalog> and the <repository> arguments') self.__allegro_server = AllegroGraphServer(self.__server, port = self.__port) self.__allegro_catalog = self.__allegro_server.openCatalog(self.__catalog) if type(self.__repository) == list and len(self.__repository) > 1: connections_to_federate = [] repositories_to_federate = [] for one_repository in self.__repository: repositories_to_federate.append(self.__allegro_catalog .getRepository(one_repository, Repository.ACCESS)) connections_to_federate.append(self.__allegro_catalog .getRepository(one_repository, Repository.ACCESS) .initialize().getConnection()) self.__allegro_repository = repositories_to_federate self.__con = self.__allegro_server.openFederated(connections_to_federate, True) else: if type(self.__repository) == list and len(self.__repository) == 1: self.__repository = self.__repository[0] self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS) self.__allegro_repository.initialize() self.__con = self.allegro_repository.getConnection() results_format = property(lambda self: 'json') server = property(lambda self: self.__server) port = property(lambda self: self.__port) catalog = property(lambda self: self.__catalog) repository = property(lambda self: self.__repository) allegro_server = property(lambda self: self.__allegro_server) allegro_catalog = property(lambda self: self.__allegro_catalog) allegro_repository = property(lambda self: self.__allegro_repository) def _to_table(self, result): table = [] bindings = result.getBindingNames() for bindingSet in result: row = {} for key in bindings: try: v = toRdfLib(bindingSet[key]) except: v = None row[key] = v table.append(row) return table def _ask(self, result): ''' returns the boolean value of a ASK query ''' return result # execute def _execute(self, query): if query.query_type == 'select': return self.__execute_sparql(unicode(query)) elif query.query_type == 'ask': return self.__execute_ask(unicode(query)) def __execute_ask(self, q_string): boolQuery = self.__con.prepareBooleanQuery(QueryLanguage.SPARQL, q_string) return boolQuery.evaluate() def __execute_sparql(self, q_string, **kwargs): self.log.debug(q_string) tupleQuery = self.__con.prepareTupleQuery(QueryLanguage.SPARQL, q_string) inference = kwargs['inference'] if 'inference' in kwargs else self.inference tupleQuery.setIncludeInferred(inference) return tupleQuery.evaluate() def execute_sparql(self, q_string, format = 'JSON'): results = self.__execute_sparql(q_string) return self._results_to_json(results) if format == 'JSON' else results def close(self): self.__con.close() def _results_to_json(self, results): bindings = results.getBindingNames() r_dict = {} r_dict['head'] = {'vars': bindings} r_dict['results'] = {'bindings':[]} for bindingSet in results: json_binding = {} for b in bindings: value = bindingSet.getValue(b) if type(value) is sv.URI: json_binding[b] = {'type':'uri', 'value': value.getURI()} elif type(value) is sv.BNode: json_binding[b] = {'type':'bnode', 'value': value.getID()} elif type(value) is sl.Literal: dtype = value.getDatatype() if value.getDatatype() else None lang = value.getLanguage() if value.getLanguage() else None lit_type = 'typed-literal' if dtype else 'literal' json_binding[b] = {'type':lit_type, 'value': value.getLabel()} if dtype: if type(dtype) in [str, unicode] and dtype.startswith('<') and dtype.endswith('>'): dtype = dtype.strip('<>') json_binding[b]['datatype'] = URIRef(dtype) if lang: json_binding[b]['xml:lang'] = lang r_dict['results']['bindings'].append(json_binding) return r_dict
class Store(object): def __init__(self, **confs): accessMode = Repository.RENEW self.port = str(confs.get('port', "8080")) self.user = confs.get('user','test') self.password = confs.get('password','xyzzy') self.dbname = confs.get('dbname','scratch') self.server = AllegroGraphServer("localhost", port=self.port, user=self.user, password=self.password) self.catalog = self.server.openCatalog(self.dbname) self.repo = self.catalog.getRepository(self.dbname, accessMode) self.repo.initialize() self.conn = self.repo.getConnection() def close(self): self.conn.close() def __len__(self): """ Returns size of the store """ return self.conn.size() def add(self, triple): return self.conn.add(*map(lambda x:self._format(x), triple)) def remove(self, triple): return self.conn.remove(*map(lambda x:self._format(x), triple)) def commit(self): return self.conn.commit() def triples(self, triple=(None,None,None)): for tri in self.conn.getStatements(*map(lambda x:self._format(x), triple)): s = self._rformat(tri.getSubject()) p = self._rformat(tri.getPredicate()) o = self._rformat(tri.getObject()) yield (s,p,o) def query(self, q, initNs={}, initBindings={}): # prepare Namespaces for prefix in initNs.keys(): self.conn.setNamespace(prefix, str(initNs[prefix])) query = q tupleQuery = self.conn.prepareTupleQuery(QueryLanguage.SPARQL, query) # prepare Bindings for var in initBindings.keys(): tupleQuery.setBinding(var, self._format(initBindings[var])) for bindingSet in tupleQuery.evaluate(): row = [] for index in range(bindingSet.size()): row.append(self._rformat(bindingSet[index])) yield row def _rformat(self, v): if isinstance(v, FURI): return URIRef(v.getURI()) if isinstance(v, FLiteral): if str(v.datatype) != "<None>": return Literal(v.toPython(), datatype=str(v.datatype)) else: return Literal(v.toPython()) else: return Literal(str(v)) def _format(self, el): if el == None: return None elif isinstance(el, FURI) or isinstance(el, FLiteral): return el elif isinstance(el, URIRef): return self.conn.createURI(str(el)) elif isinstance(el, Literal): return self.conn.createLiteral(str(el), datatype=str(el.datatype)) else: "Defaults to literal" return self.conn.createLiteral(str(el))
class Store(object): def __init__(self, **confs): accessMode = Repository.OPEN self.port = str(confs.get('port', '10035')) self.user = confs.get('user', 'toolate') self.password = confs.get('password', 'toolate') self.dbname = confs.get('dbname', 'system') self.server = AllegroGraphServer(host="83.212.105.61", port=10035, user="******", password="******") self.catalog = self.server.openCatalog(self.dbname) self.repo = self.catalog.getRepository("darwinsmusic", accessMode) self.repo.initialize() self.conn = self.repo.getConnection() def close(self): self.conn.close() def __len__(self): """ Returns size of the store """ return self.conn.size() def add(self, triple): return self.conn.add(*map(lambda x: self._format(x), triple)) def remove(self, triple): return self.conn.remove(*map(lambda x: self._format(x), triple)) def commit(self): return self.conn.commit() def triples(self, triple=(None, None, None)): for tri in self.conn.getStatements( *map(lambda x: self._format(x), triple)): s = self._rformat(tri.getSubject()) p = self._rformat(tri.getPredicate()) o = self._rformat(tri.getObject()) yield (s, p, o) def query(self, q, initNs={}, initBindings={}): # prepare Namespaces for prefix in initNs.keys(): self.conn.setNamespace(prefix, str(initNs[prefix])) query = q tupleQuery = self.conn.prepareTupleQuery(QueryLanguage.SPARQL, query) # prepare Bindings for var in initBindings.keys(): tupleQuery.setBinding(var, self._format(initBindings[var])) results = [] for bindingSet in tupleQuery.evaluate(): row = [] for index in range(bindingSet.size()): row.append(self._rformat(bindingSet[index])) results.append(row) return results def _rformat(self, v): if isinstance(v, FURI): return URIRef(v.getURI()) if isinstance(v, FLiteral): if str(v.datatype) != "<None>": return Literal(v.toPython(), datatype=str(v.datatype)) else: return Literal(v.toPython()) else: return Literal(str(v)) def _format(self, el): if el is None: return None elif isinstance(el, FURI) or isinstance(el, FLiteral): return el elif isinstance(el, URIRef): return self.conn.createURI(str(el)) elif isinstance(el, Literal): return self.conn.createLiteral(str(el), datatype=str(el.datatype)) else: "Defaults to literal" return self.conn.createLiteral(str(el))
class WriterPlugin(RDFWriter): def __init__(self, reader, *args, **kwargs): RDFWriter.__init__(self, reader, *args, **kwargs) if isinstance(self.reader, ReaderPlugin): self.__server = self.reader.server self.__port = self.reader.port self.__catalog = self.reader.catalog self.__repository = self.reader.repository self.__allegro_server = self.reader.allegro_server self.__allegro_catalog = self.reader.allegro_catalog self.__allegro_repository = self.reader.allegro_repository else: self.__server = kwargs['server'] if 'server' in kwargs else 'localhost' self.__port = kwargs['port'] if 'port' in kwargs else 6789 self.__catalog = kwargs['catalog'] if 'catalog' in kwargs else None self.__repository = kwargs['repository'] if 'repository' in kwargs else None if not self.__catalog or not self.__repository: raise Exception('Must specify the <catalog> and the <repository> arguments') self.__allegro_server = AllegroGraphServer(self.__server, port = self.__port) self.__allegro_catalog = self.__allegro_server.openCatalog(self.__catalog) self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS) self.__allegro_repository.initialize() self.__con = self.__allegro_repository.getConnection() self.__f = self.__allegro_repository.getValueFactory() results_format = property(lambda self: 'json') server = property(lambda self: self.__server) port = property(lambda self: self.__port) catalog = property(lambda self: self.__catalog) repository = property(lambda self: self.__repository) allegro_server = property(lambda self: self.__allegro_server) allegro_catalog = property(lambda self: self.__allegro_catalog) allegro_repository = property(lambda self: self.__allegro_repository) def _save(self, *resources): for resource in resources: s = resource.subject self.__remove(s, context=resource.context) for p, objs in resource.rdf_direct.items(): for o in objs: self.__add(s, p, o, resource.context) def _update(self, *resources): for resource in resources: s = resource.subject for p in resource.rdf_direct: self.__remove(s, p, context=resource.context) for p, objs in resource.rdf_direct.items(): for o in objs: self.__add(s, p, o, resource.context) def _remove(self, *resources, **kwargs): inverse = kwargs.get("inverse") for resource in resources: self.__remove(s = resource.subject, context=resource.context) if inverse: self.__remove(o = resource.subject, context=resource.context) def _size(self): return self.__con.size() def _add_triple(self, s = None, p = None, o = None, context = None): self.__add(s, p, o, context) def _set_triple(self, s = None, p = None, o = None, context = None): self.__remove(s, p, context = context) self.__add(s, p, o, context) def _remove_triple(self, s = None, p = None, o = None, context = None): self.__remove(s, p, o, context) # used by the sesame api def __add(self, s = None, p = None, o = None, context = None): info('ADD TRIPLE: %s, %s, %s, %s' % (s, p, o, context)) self.__con.addTriple(toSesame(s, self.__f), toSesame(p, self.__f), toSesame(o, self.__f), contexts = toSesame(context, self.__f)) def __remove(self, s = None, p = None, o = None, context = None): info('REM TRIPLE: %s, %s, %s, %s' % (s, p, o, context)) self.__con.removeTriples(toSesame(s, self.__f), toSesame(p, self.__f), toSesame(o, self.__f), contexts = toSesame(context, self.__f)) def index_triples(self, **kwargs): """ Index triples if this functionality is present. Return `True` if successful. """ all = kwargs['all'] if 'all' in kwargs else False asynchronous = kwargs['asynchronous'] if 'asynchronous' in kwargs else False self.__allegro_repository.indexTriples(all = all, asynchronous = asynchronous) return True def load_triples(self, **kwargs): ''' loads triples from supported sources if such functionality is present returns True if operation successfull ''' format = kwargs['format'] if 'format' in kwargs else RDFFormat.RDFXML format = RDFFormat.NTRIPLES if format is 'nt' else RDFFormat.RDFXML source = kwargs['source'] if 'source' in kwargs else None base = kwargs['base'] if 'base' in kwargs else None context = kwargs['context'] if 'context' in kwargs else None server_side = kwargs['server_side'] if 'server_side' in kwargs else True if source: self.__con.addFile(source, base = base, format = format, context = toSesame(context, self.__f), serverSide = server_side) return True return False def _clear(self, context = None): """ Clear the triple-store. """ self.__con.clear(contexts = toSesame(context, self.__f)) # Extra functionality def register_fts_predicate(self, namespace, localname): ''' register free text search predicates ''' self.__allegro_repository.registerFreeTextPredicate(namespace = unicode(namespace), localname = localname) def namespaces(self): return self.__con.getNamespaces() def namespace(self, prefix): return self.__con.getNamespace(prefix) def set_namespace(self, prefix, namespace): self.__con.setNamespace(prefix, namespace) def remove_namespace(self, prefix): self.__con.removeNamespace(prefix) def clear_namespaces(self): self.__con.clearNamespaces() def close(self): self.__con.close()
def __init__(self): try: os.system("rm /var/log/callisto/allegro_fcts.log") except: pass log.basicConfig(filename='/var/log/callisto/allegro_fcts.log', level=log.DEBUG, format='%(levelname)s:%(asctime)s %(message)s ') self.read_config() self.form = cgi.FieldStorage() self.usecase = str(self.form.getvalue("case")) repo = str(self.form.getvalue("repo")) self.usecase = str(self.form.getvalue("case")) self.input_svc = str(self.form.getvalue("dataset")) self.list_inputs_svc = [] self.list_inputs_svc.append(self.input_svc) self.Iseek = str(self.form.getvalue("query")) self.service = str(self.form.getvalue("service")) self.claim = str(self.form.getvalue("claim")) self.output_svc = "" self.statement = "NONE" self.publisher = "Unknown" self.description = "" self.data_desc = "Not provided" self.csv_file = "general_file.csv" self.general_file = open("../html/callisto/TempFiles/" + self.csv_file, 'w') self.concepts_dict = {} self.data_dict = {} self.operations = [] self.citation = [] self.publisher = [] self.final_services = [] self.citation = [] self.services = [] self.tested_services = [] self.send_header() if repo == "all": log.debug("Seeking available repositories in catalog") server = AllegroGraphServer(host=self.host, port=self.port, user=self.user, password=self.password) catalog = server.openCatalog('') # log.info("Available repositories in catalog '%s':" % catalog.getName()) # log.info("Available repositories in catalog:" % str(catalog.listRepositories())) for repo_name in catalog.listRepositories(): self.repository = repo_name.upper() self.myont = self.rootiri + self.repository + ".rdf" log.debug("querying repo: " + str(repo_name)) self.repo = self.open_connection(repo_name)[0] self.conn = self.open_connection(repo_name)[1] self.switch_case() # self.send_response() self.close_connection() else: self.repository = repo.upper() self.myont = self.rootiri + self.repository + ".rdf" self.repo = self.open_connection(repo)[0] self.conn = self.open_connection(repo)[1] self.switch_case() # self.send_response() self.close_connection() self.general_file.close() self.send_footer()
class ReaderPlugin(RDFQueryReader): def __init__(self, *args, **kwargs): RDFQueryReader.__init__(self, *args, **kwargs) self.__server = kwargs['server'] if 'server' in kwargs else 'localhost' self.__port = kwargs['port'] if 'port' in kwargs else 6789 self.__catalog = kwargs['catalog'] if 'catalog' in kwargs else None self.__repository = kwargs[ 'repository'] if 'repository' in kwargs else None if not self.__catalog or not self.__repository: raise Exception( 'Must specify the <catalog> and the <repository> arguments') self.__allegro_server = AllegroGraphServer(self.__server, port=self.__port) self.__allegro_catalog = self.__allegro_server.openCatalog( self.__catalog) self.__allegro_repository = self.__allegro_catalog.getRepository( self.__repository, Repository.ACCESS) self.__allegro_repository.initialize() self.__con = self.allegro_repository.getConnection() results_format = property(lambda self: 'json') server = property(lambda self: self.__server) port = property(lambda self: self.__port) catalog = property(lambda self: self.__catalog) repository = property(lambda self: self.__repository) allegro_server = property(lambda self: self.__allegro_server) allegro_catalog = property(lambda self: self.__allegro_catalog) allegro_repository = property(lambda self: self.__allegro_repository) def _to_table(self, result): table = [] bindings = result.getBindingNames() for bindingSet in result: row = {} for key in bindings: try: v = toRdfLib(bindingSet[key]) except: v = None row[key] = v table.append(row) return table def _ask(self, result): ''' returns the boolean value of a ASK query ''' return result # execute def _execute(self, query): if query.query_type == 'select': return self.__execute_select(str(query)) elif query.query_type == 'ask': return self.__execute_ask(str(query)) def __execute_ask(self, q_string): debug(q_string) boolQuery = self.__con.prepareBooleanQuery(QueryLanguage.SPARQL, q_string) return boolQuery.evaluate() def __execute_select(self, q_string): debug(q_string) tupleQuery = self.__con.prepareTupleQuery(QueryLanguage.SPARQL, q_string) tupleQuery.setIncludeInferred(self.inference) return tupleQuery.evaluate() def execute_sparql(self, q_string, format='JSON'): debug(q_string) tupleQuery = self.__con.prepareQuery(QueryLanguage.SPARQL, q_string) tupleQuery.setIncludeInferred(self.inference) # Do some magic as Franz's API doesn't provide a unified API for # ask & select result = tupleQuery.evaluate_generic_query() if format == 'JSON': if type(result) is dict: response = TupleQueryResult(result['names'], result['values']) return self._results_to_json(response) else: # Build our own JSON response return {'head': {}, 'boolean': result} else: return result def close(self): self.__con.close() def _results_to_json(self, results): bindings = results.getBindingNames() r_dict = {} r_dict['head'] = {'vars': bindings} r_dict['results'] = {'bindings': []} for bindingSet in results: json_binding = {} for b in bindings: value = bindingSet.getValue(b) if type(value) is sv.URI: json_binding[b] = {'type': 'uri', 'value': value.getURI()} elif type(value) is sv.BNode: json_binding[b] = {'type': 'bnode', 'value': value.getID()} elif type(value) is sl.Literal: dtype = value.getDatatype() if value.getDatatype( ) else None lang = value.getLanguage() if value.getLanguage() else None lit_type = 'typed-literal' if dtype else 'literal' json_binding[b] = { 'type': lit_type, 'value': value.getLabel() } if dtype: if type(dtype) is sv.URI: json_binding[b]['datatype'] = dtype.getURI() elif type(dtype) in [ str, str ] and dtype.startswith('<') and dtype.endswith('>'): json_binding[b]['datatype'] = URIRef( dtype.strip('<>')) else: json_binding[b]['datatype'] = URIRef(dtype) if lang: json_binding[b]['xml:lang'] = lang r_dict['results']['bindings'].append(json_binding) return r_dict
class WriterPlugin(RDFWriter): def __init__(self, reader, *args, **kwargs): RDFWriter.__init__(self, reader, *args, **kwargs) if isinstance(self.reader, ReaderPlugin): self.__server = self.reader.server self.__port = self.reader.port self.__catalog = self.reader.catalog self.__repository = self.reader.repository self.__allegro_server = self.reader.allegro_server self.__allegro_catalog = self.reader.allegro_catalog self.__allegro_repository = self.reader.allegro_repository if type(self.__repository) == list and len(self.__repository) > 1: connections_to_federate = [] repositories_to_federate = [] for one_repository in self.reader.allegro_repository: repositories_to_federate.append(self.__allegro_catalog .getRepository(one_repository, Repository.ACCESS)) connections_to_federate.append(self.__allegro_catalog .getRepository(one_repository, Repository.ACCESS) .initialize().getConnection()) self.__allegro_repository = repositories_to_federate self.__con = self.__allegro_server.openFederated(connections_to_federate, True) else: if type(self.__repository) == list and len(self.__repository) == 1: self.__repository = self.__repository[0] self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS) self.__allegro_repository.initialize() self.__con = self.allegro_repository.getConnection() else: self.__server = kwargs['server'] if 'server' in kwargs else 'localhost' self.__port = kwargs['port'] if 'port' in kwargs else 6789 self.__catalog = kwargs['catalog'] if 'catalog' in kwargs else None self.__repository = kwargs['repository'] if 'repository' in kwargs else None if not self.__catalog or not self.__repository: raise Exception('Must specify the <catalog> and the <repository> arguments') self.__allegro_server = AllegroGraphServer(self.__server, port = self.__port) self.__allegro_catalog = self.__allegro_server.openCatalog(self.__catalog) if type(self.__repository) == list and len(self.__repository) > 1: connections_to_federate = [] repositories_to_federate = [] for repository in self.__repository: repositories_to_federate.append(self.__allegro_catalog .getRepository(repository, Repository.ACCESS)) connections_to_federate.append(self.__allegro_catalog .getRepository(repository, Repository.ACCESS) .initialize().getConnection()) self.__allegro_repository = repositories_to_federate self.__con = self.__allegro_server.openFederated(connections_to_federate, True) else: if type(self.__repository) == list and len(self.__repository) == 1: self.__repository = self.__repository[0] self.__allegro_repository = self.__allegro_catalog.getRepository(self.__repository, Repository.ACCESS) self.__allegro_repository.initialize() self.__con = self.allegro_repository.getConnection() results_format = property(lambda self: 'json') server = property(lambda self: self.__server) port = property(lambda self: self.__port) catalog = property(lambda self: self.__catalog) repository = property(lambda self: self.__repository) allegro_server = property(lambda self: self.__allegro_server) allegro_catalog = property(lambda self: self.__allegro_catalog) allegro_repository = property(lambda self: self.__allegro_repository) def _save(self, *resources): for resource in resources: s = resource.subject self.__remove(s) for p, objs in resource.rdf_direct.items(): for o in objs: self.__add(s, p, o) def _update(self, *resources): for resource in resources: s = resource.subject for p in resource.rdf_direct: self.__remove(s, p) for p, objs in resource.rdf_direct.items(): for o in objs: self.__add(s, p, o) def _remove(self, *resources, **kwargs): inverse = kwargs.get("inverse") for resource in resources: self.__remove(s = resource.subject) if inverse: self.__remove(o = resource.subject) def _size(self): return self.__con.size() def _add_triple(self, s = None, p = None, o = None, context = None): self.__add(s, p, o, context) def _set_triple(self, s = None, p = None, o = None, context = None): self.__remove(s, p, context = context) self.__add(s, p, o, context) def _remove_triple(self, s = None, p = None, o = None, context = None): self.__remove(s, p, o, context) # used by the sesame api def __add(self, s = None, p = None, o = None, context = None): self.log.info('ADD TRIPLE: ' + unicode(s) + ', ' + unicode(p) + ', ' + unicode(o) + ', ' + unicode(context)) self.__con.addTriple(toSesame(s, self.__con), toSesame(p, self.__con), toSesame(o, self.__con), contexts = toSesame(context, self.__con)) def __remove(self, s = None, p = None, o = None, context = None): self.log.info('REM TRIPLE: ' + unicode(s) + ', ' + unicode(p) + ', ' + unicode(o) + ', ' + unicode(context)) self.__con.removeTriples(toSesame(s, self.__con), toSesame(p, self.__con), toSesame(o, self.__con), contexts = toSesame(context, self.__con)) def index_triples(self, **kwargs): """ Index triples if this functionality is present. Return `True` if successful. """ all = kwargs['all'] if 'all' in kwargs else False asynchronous = kwargs['asynchronous'] if 'asynchronous' in kwargs else False self.__allegro_repository.indexTriples(all = all, asynchronous = asynchronous) return True def load_triples(self, **kwargs): ''' loads triples from supported sources if such functionality is present returns True if operation successfull ''' format = kwargs['format'] if 'format' in kwargs else RDFFormat.RDFXML format = RDFFormat.NTRIPLES if format is 'nt' else RDFFormat.RDFXML source = kwargs['source'] if 'source' in kwargs else None base = kwargs['base'] if 'base' in kwargs else None context = kwargs['context'] if 'context' in kwargs else None server_side = kwargs['server_side'] if 'server_side' in kwargs else True if source: self.__con.addFile(source, base = base, format = format, context = toSesame(context, self.__con), serverSide = server_side) return True return False def _clear(self, context = None): """ Clear the triple-store. """ self.__con.clear(contexts = toSesame(context, self.__con)) # Extra functionality def register_fts_predicate(self, namespace, localname): ''' register free text search predicates ''' self.__allegro_repository.registerFreeTextPredicate(namespace = unicode(namespace), localname = localname) def namespaces(self): return self.__con.getNamespaces() def namespace(self, prefix): return self.__con.getNamespace(prefix) def set_namespace(self, prefix, namespace): self.__con.setNamespace(prefix, namespace) def remove_namespace(self, prefix): self.__con.removeNamespace(prefix) def clear_namespaces(self): self.__con.clearNamespaces() def close(self): self.__con.close()
def obtenerRepositorio(repositorio): serverAG = AllegroGraphServer('localhost', port=10035, user='******', password='******') catalogo = serverAG.openCatalog('') Repositorio = catalogo.getRepository(repositorio, Repository.ACCESS) Repositorio.initialize() return Repositorio