def __init__(self, app, session):
"""init
Parameters
----------
app : Flask
Flask app
session :
AskOmics session
"""
Params.__init__(self, app, session)
self.namespace_data = self.settings.get('triplestore',
'namespace_data')
self.namespace_internal = self.settings.get('triplestore',
'namespace_internal')
self.prefix = {
':': self.settings.get('triplestore', 'namespace_data'),
'askomics:': self.settings.get('triplestore',
'namespace_internal'),
'prov:': 'http://www.w3.org/ns/prov#',
'dc:': 'http://purl.org/dc/elements/1.1/',
'faldo:': "http://biohackathon.org/resource/faldo/",
'rdf:': str(rdflib.RDF),
'rdfs:': str(rdflib.RDFS),
'owl:': str(rdflib.OWL),
'xsd:': str(rdflib.XSD)
}
def __init__(self, app, session):
"""init
Parameters
----------
app : Flask
Flask app
session :
AskOmics session
"""
Params.__init__(self, app, session)
self.graphs = []
self.endpoints = []
self.selects = []
self.federated = False
# local endpoint (for federated query engine)
self.local_endpoint_f = self.settings.get('triplestore', 'endpoint')
try:
self.local_endpoint_f = self.settings.get('federation',
'local_endpoint')
except Exception:
pass
self.set_graphs_and_endpoints()
def __init__(self, app, session, dataset_info={}):
"""init
Parameters
----------
app : Flask
Flask app
session :
AskOmics session
dataset_info : dict, optional
Dataset info
"""
Params.__init__(self, app, session)
self.id = dataset_info["id"] if "id" in dataset_info else None
self.celery_id = dataset_info[
"celery_id"] if "celery_id" in dataset_info else None
self.file_id = dataset_info[
"file_id"] if "file_id" in dataset_info else None
self.name = dataset_info["name"] if "name" in dataset_info else None
self.graph_name = dataset_info[
"graph_name"] if "graph_name" in dataset_info else None
self.public = dataset_info[
"public"] if "public" in dataset_info else False
self.start = dataset_info["start"] if "start" in dataset_info else None
self.end = dataset_info["end"] if "end" in dataset_info else None
def __init__(self, app, session):
"""init
Parameters
----------
app : Flask
Flask app
session
AskOmics session
"""
Params.__init__(self, app, session)
self.namespace_data = Namespace(
self.settings.get('triplestore', 'namespace_data'))
self.namespace_internal = Namespace(
self.settings.get('triplestore', 'namespace_internal'))
self.graph = rdflib.Graph()
self.graph.bind('', self.namespace_data)
self.graph.bind('askomics', self.namespace_internal)
self.graph.bind('faldo', "http://biohackathon.org/resource/faldo/")
self.graph.bind('dc', 'http://purl.org/dc/elements/1.1/')
self.graph.bind('prov', 'http://www.w3.org/ns/prov#')
self.ntriple = 0
self.percent = None
def __init__(self, app, session):
"""Get ldap config
Parameters
----------
app : Flask
flask app
session
AskOmics session, contain the user
"""
Params.__init__(self, app, session)
self.ldap = self.app.iniconfig.getboolean("askomics", "ldap_auth")
if self.ldap:
self.host = self.app.iniconfig.get("askomics", "ldap_host")
self.port = self.app.iniconfig.get("askomics", "ldap_port")
self.bind_dn = self.app.iniconfig.get("askomics", "ldap_bind_dn")
self.bind_password = self.app.iniconfig.get(
"askomics", "ldap_bind_password")
self.search_base = self.app.iniconfig.get("askomics",
"ldap_search_base")
self.user_filter = self.app.iniconfig.get("askomics",
"ldap_user_filter")
self.username_attribute = self.app.iniconfig.get(
"askomics", "ldap_username_attribute")
self.first_name_attribute = self.app.iniconfig.get(
"askomics", "ldap_first_name_attribute")
self.surname_attribute = self.app.iniconfig.get(
"askomics", "ldap_surname_attribute")
self.mail_attribute = self.app.iniconfig.get(
"askomics", "ldap_mail_attribute")
def __init__(self, app, session, url=None, apikey=None):
"""init
Parameters
----------
app : Flask
flask app
session :
AskOmics session, contain the user
url : string
Galaxy url
apikey : string
Galaxy API key
"""
Params.__init__(self, app, session)
if not url and not apikey:
self.url = self.session["user"]["galaxy"]["url"]
self.apikey = self.session["user"]["galaxy"]["apikey"]
else:
self.url = url
self.apikey = apikey
self.upload_path = "{}/{}_{}/upload".format(
self.settings.get("askomics", "data_directory"),
self.session['user']['id'], self.session['user']['username'])
def __init__(self,
app,
session,
get_result_query=False,
federated=False,
endpoints=None):
"""init
Parameters
----------
app : Flask
Flask app
session :
AskOmics session
"""
Params.__init__(self, app, session)
self.query_time = None
# local endpoint (for federated query engine)
self.local_endpoint_f = self.settings.get('triplestore', 'endpoint')
try:
self.local_endpoint_f = self.settings.get('federation',
'local_endpoint')
except Exception:
pass
# Use the federated query engine
if federated:
self.federated = True
self.local_query = False
self.url_endpoint = self.settings.get('federation', 'endpoint')
self.url_updatepoint = self.settings.get('federation', 'endpoint')
self.triplestore = self.settings.get('federation', 'query_engine')
# use the external endpoint
elif endpoints is not None and endpoints != [self.local_endpoint_f]:
self.federated = False
self.local_query = False
self.triplestore = "unknown"
self.url_endpoint = endpoints[0]
self.url_updatepoint = endpoints[0]
# use the local endpoint
else:
self.federated = False
self.local_query = True
self.triplestore = self.settings.get('triplestore', 'triplestore')
self.url_endpoint = self.settings.get('triplestore', 'endpoint')
self.url_updatepoint = self.settings.get('triplestore',
'updatepoint')
try:
self.endpoint.setCredentials(
self.settings.get('triplestore', 'username'),
self.settings.get('triplestore', 'password'))
except Exception:
pass
self.endpoint = SPARQLWrapper(self.url_endpoint, self.url_updatepoint)
def __init__(self, app, session):
"""init
Parameters
----------
app : Flask
flask app
session :
AskOmics session, contain the user
"""
Params.__init__(self, app, session)
def __init__(self, app, session):
"""Store the database path
Parameters
----------
app :
flask app
session :
flask session
"""
Params.__init__(self, app, session)
self.database_path = self.settings.get('askomics', 'database_path')
def __init__(self, app, session, datasets_info=[]):
"""init
Parameters
----------
app : Flask
Flask app
session :
AskOmics session
datasets_info : list, optional
Dataset info
"""
Params.__init__(self, app, session)
self.datasets_info = datasets_info
self.datasets = []
def __init__(self, app, session, result_info, force_no_db=False):
"""init object
Parameters
----------
app : Flask
flask app
session :
AskOmics session, contain the user
result_info : dict
Result file info
"""
Params.__init__(self, app, session)
if "user" in self.session:
self.result_path = "{}/{}_{}/results".format(
self.settings.get("askomics", "data_directory"),
self.session['user']['id'], self.session['user']['username'])
if "id" in result_info and not force_no_db:
self.id = result_info["id"]
if not self.set_info_from_db_with_id():
return None
else:
self.id = result_info["id"] if "id" in result_info else None
self.graph_state = result_info[
"graph_state"] if "graph_state" in result_info else None
self.graphs = result_info[
"graphs"] if "graphs" in result_info else []
self.endpoints = result_info[
"endpoints"] if "endpoints" in result_info else []
self.sparql_query = result_info[
"sparql_query"] if "sparql_query" in result_info else None
self.celery_id = result_info[
"celery_id"] if "celery_id" in result_info else None
self.file_name = result_info[
"file_name"] if "file_name" in result_info else Utils.get_random_string(
10)
self.file_path = "{}/{}".format(self.result_path, self.file_name)
self.start = None
self.end = None
self.nrows = 0
self.has_form_attr = False
self.template = False
self.form = False
def __init__(self,
app,
session,
file_info,
host_url=None,
external_endpoint=None,
custom_uri=None):
"""init
Parameters
----------
app : Flask
Flask app
session :
AskOmics session
file_info : dict
File info
host_url : None, optional
AskOmics url
"""
Params.__init__(self, app, session)
self.host_url = host_url
self.human_name = file_info["name"]
self.name = self.format_uri(file_info['name'], remove_space=True)
self.path = file_info['path']
self.type = file_info['type']
self.size = file_info['size']
self.id = file_info['id']
self.public = False
self.ntriples = 0
self.timestamp = int(time.time())
self.external_endpoint = external_endpoint
self.default_graph = "{}".format(
self.settings.get('triplestore', 'default_graph'))
self.user_graph = "{}:{}_{}".format(
self.settings.get('triplestore', 'default_graph'),
self.session['user']['id'], self.session['user']['username'])
if "graph_name" not in file_info:
self.file_graph = "{}:{}_{}:{}_{}".format(
self.settings.get('triplestore',
'default_graph'), self.session['user']['id'],
self.session['user']['username'], self.name, self.timestamp)
else:
self.file_graph = file_info["graph_name"]
self.ttl_dir = '{}/{}_{}/ttl'.format(
self.settings.get('askomics', 'data_directory'),
self.session['user']['id'], self.session['user']['username'])
self.now = datetime.datetime.now().isoformat()
self.askomics_namespace = Namespace(
self.settings.get('triplestore', 'namespace'))
self.askomics_prefix = Namespace(
self.settings.get('triplestore', 'prefix'))
self.entity_prefix = Namespace(
custom_uri) if custom_uri else self.askomics_prefix
self.faldo = Namespace('http://biohackathon.org/resource/faldo/')
self.prov = Namespace('http://www.w3.org/ns/prov#')
self.dc = Namespace('http://purl.org/dc/elements/1.1/')
self.faldo_entity = False
self.faldo_abstraction = {
"start": None,
"end": None,
"strand": None,
"reference": None
}
self.faldo_abstraction_eq = {
"start": self.askomics_namespace["faldoStart"],
"end": self.askomics_namespace["faldoEnd"],
"strand": self.askomics_namespace["faldoStrand"],
"reference": self.askomics_namespace["faldoReference"]
}
self.method = self.settings.get('triplestore', 'upload_method')
self.max_chunk_size = self.settings.getint('triplestore', 'chunk_size')
self.serialization_format = self.settings.get('triplestore',
'serialization_format')
self.rdf_extention = 'ttl' if self.serialization_format == 'turtle' else self.serialization_format
self.graph_chunk = RdfGraph(self.app, self.session)
self.graph_abstraction_dk = RdfGraph(self.app, self.session)
self.error = False
self.error_message = ""
