sparql.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from hashlib import md5
from rdflib import Graph
from rdflib.plugins.sparql.results.csvresults import CSVResultSerializer
from SPARQLWrapper import SPARQLWrapper, CSV
from SPARQLWrapper.SPARQLExceptions import EndPointInternalError, EndPointNotFound, SPARQLWrapperException, Unauthorized

from logger import ErrorLogger

import re


class SPARQL:
    def __init__(self, config, type):
        if type != 'source' and type != 'target':
            raise Exception("Wrong type (not source or target) specified")

        self.config = config
        self.type = type
        self.query_hash = self.get_query_hash()
        self.sparql_error_logger = ErrorLogger('SparqlErrorLogger', 'sparql_errors', self.query_hash)

    def build_query(self, offset, limit=None):
        if self.config.get_rawquery(self.type) is not None:
            query = self.config.get_rawquery(self.type)
            query_offset = 'OFFSET {}'.format(offset) if self.config.get_endpoint_type(self.type) == 'remote' else ''
            query = '{} {}'.format(query, query_offset)
            query_limit = 'LIMIT {}'.format(limit) if self.config.get_endpoint_type(self.type) == 'remote' else ''
            if limit is None:
                return query
            query = '{} {}'.format(query, query_limit)
            return query
        else:
            query_prefixes = self.build_prefixes()
            query_select = 'SELECT DISTINCT ?{} ?{}'.format(self.config.get_var_uri(self.type), self.config.get_var_shape(self.type))
            query_from = 'FROM <{}>'.format(self.config.get_graph(self.type))
            query_where = self.build_where()
            query_offset = 'OFFSET {}'.format(offset) if self.config.get_endpoint_type(self.type) == 'remote' else ''
            query_limit = 'LIMIT {}'.format(limit) if self.config.get_endpoint_type(self.type) == 'remote' else ''
            query = '{} {} {} {} {}'.format(query_prefixes, query_select, query_from, query_where, query_offset)

            if limit is None:
                return query

            return '{} {}'.format(query, query_limit)

    def build_prefixes(self):
        prefixes = self.config.get_prefixes()

        if prefixes is None:
            return ''

        query_prefixes = ''

        for prefix in prefixes:
            if len(query_prefixes) > 0:
                query_prefixes += ' '

            current_prefix = 'PREFIX {}: <{}>'.format(prefix['label'], prefix['namespace'])
            query_prefixes += current_prefix

        return query_prefixes

    def build_where(self):
        restriction = self.config.get_restriction(self.type)
        property = self.config.get_property(self.type)
        query_where = 'WHERE {'

        if restriction is not None:
            query_where += restriction + ' . '

        if property is not None:
            query_where += property + ' . '

        query_where += '}'

        return query_where

    def clean_query(self, query):
        query = re.sub('\n', ' ', query)
        query = re.sub('[ ]+', ' ', query)
        query = re.sub('[ ]?{[ ]?', ' {', query)
        query = re.sub('[ ]?}[ ]?', '} ', query)

        return query

    def query(self, offset, limit=None):
        query = self.build_query(offset, limit)

        if self.config.get_endpoint_type(self.type) == 'remote': 
            sparql = SPARQLWrapper(self.config.get_endpoint(self.type))
            sparql.customHttpHeaders['Accept-Encoding'] = 'gzip'
            sparql.setQuery(query)
            sparql.setReturnFormat(CSV)

            try:
                return sparql.query()
            except EndPointNotFound as e:
                print(e)
            except Unauthorized as e:
                print(e)
            except EndPointInternalError as e:
                print(e)
            except SPARQLWrapperException as e:
                print(e)
        elif self.config.get_endpoint_type(self.type) == 'local': 
            endpoint = self.config.get_endpoint(self.type)
            endpoint.replace('file://', '')
            graph = Graph()
            graph.parse(endpoint, format='nt')
            result = graph.query(query)
            return result.serialize(format='csv')

        return None

    def get_query_hash(self):
        query = self.clean_query(self.build_query(0))
        return md5(query.encode('utf-8')).hexdigest()