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 __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()
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 __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 __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()
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 example0():
"""
Can we connect to AG?
"""
print ("Starting example example0().")
print "Current working directory is '%s'" % (os.getcwd())
server = AllegroGraphServer(AG_HOST, AG_PORT, AG_USER, AG_PASSWORD)
print "Available catalogs", server.listCatalogs()
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 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 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 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 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 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 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 __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()
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 __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()
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.__user = self.reader.user
self.__password = self.reader.password
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.__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()
self.__f = self.__allegro_repository.getValueFactory()
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 __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 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 __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 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 __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 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
}
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()
def get_ag_version():
# Return the server version as a tuple.
from franz.openrdf.sail.allegrographserver import AllegroGraphServer
if 'AGRAPH_VERSION' in os.environ:
return tuple(int(x) for x in os.environ['AGRAPH_VERSION'].split('.'))
if not any(map(os.environ.get, ('AGRAPH_HOST', 'AGRAPH_PORT'))):
# We need to choose a version anyway...
return (6, 3, 1)
host = os.environ.get('AGRAPH_HOST', '127.0.0.1')
port = os.environ.get('AGRAPH_PORT', '10035')
user = os.environ.get('AGRAPH_USER', 'test')
password = os.environ.get('AGRAPH_PASSWORD', 'xyzzy')
server = AllegroGraphServer(host=host, port=port,
user=user, password=password)
return tuple(int(x) for x in server.version.split('.'))
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 __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()
from franz.openrdf.repository.repository import Repository
from franz.openrdf.rio.rdfformat import RDFFormat
from franz.openrdf.rio.rdfxmlwriter import RDFXMLWriter
import sys
import time
print("mode: " + sys.argv[1])
file_path = "/INNUENDO/backups/" + sys.argv[2]
print("file name:" + file_path)
################ CONNECTING TO ALLEGROGRAPH ############################
print("Connecting to AllegroGraph server --",
"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():
def obtenerRepositorio(repositorio):
serverAG = AllegroGraphServer('localhost', port=10035, user='******', password='******')
catalogo = serverAG.openCatalog('')
Repositorio = catalogo.getRepository(repositorio, Repository.ACCESS)
Repositorio.initialize()
return Repositorio
obo = config["obo"] 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 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 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 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 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
from franz.openrdf.sail.allegrographserver import AllegroGraphServer
from franz.openrdf.repository.repository import Repository
import pymysql
import re
from urllib import parse
import segmentation as seg
import json
import serverCONFIG as scg
from DBUtils import PooledDB
weight_of_subject = 3.1
weight_of_category = 2.1
# connect to Allegrograph
server = AllegroGraphServer(host=scg.host_agraph,
port=scg.port_agraph,
user=scg.user_agraph,
password=scg.password_agraph)
catalog = server.openCatalog("")
graph = catalog.getRepository(scg.repository_agraph, Repository.ACCESS)
graph.initialize()
conn_graph = graph.getConnection()
# connect to mysql
db_config = {
'host': scg.host_mysql,
'port': scg.port_mysql,
'user': scg.user_mysql,
'password': scg.password_mysql,
'db': scg.db_mysql,
'charset': 'utf8'
}
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()
# Copyright (C) 2019-2021 C A L M I P
# callisto is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU AFFERO GENERAL PUBLIC LICENSE for more details.
#
# You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE
# along with Callisto. If not, see <http://www.gnu.org/licenses/agpl-3.0.txt>.
#
# Authors:
# Thierry Louge - C.N.R.S. - UMS 3667 - CALMIP
# Emmanuel Courcelle - C.N.R.S. - UMS 3667 - CALMIP
#
from franz.openrdf.sail.allegrographserver import AllegroGraphServer
from franz.openrdf.repository.repository import Repository
from rdflib import Namespace, URIRef, Literal
from franz.openrdf.vocabulary import RDFS
arcas = Namespace("http://www.callisto.calmip.univ-toulouse.fr/ARCAS.rdf#")
server = AllegroGraphServer(host="CallistoAllegro",
port="{{allegro_port}}",
user="******",
password="******")
catalog = server.openCatalog('')
mode = Repository.ACCESS
repository = catalog.getRepository("demonstration", mode)
repository.initialize()
conn = repository.getConnection()
conn.addFile("/home/callisto/demonstration.nt", format="application/n-triples")
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()
"""
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', # 是否要记录下来？ 将此项单独放在一个表中
}
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
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 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
