def Main(): lib_util.SetLoggingConfig(logging.ERROR) envSparql = lib_sparql.SparqlEnvironment() grph = lib_kbase.MakeGraph() sparql_query = envSparql.Query() lib_sparql.QueryToGraph(grph, sparql_query, lib_wmi.WmiSparqlCallbackApi()) envSparql.WriteTripleStoreAsString(grph)
def Main(): logging.critical("THIS IS DEPRECATED") lib_util.SetLoggingConfig(logging.ERROR) envSparql = lib_sparql.SparqlEnvironment() grph = rdflib.Graph() sparql_query = envSparql.Query() lib_sparql.QueryToGraph(grph, sparql_query, lib_wmi.WmiSparqlCallbackApi()) envSparql.WriteTripleStoreAsString(grph)
def Main(): logging.critical("THIS IS DEPRECATED") lib_util.SetLoggingConfig(logging.ERROR) envSparql = lib_sparql.SparqlEnvironment() grph = rdflib.Graph() sparql_query = envSparql.Query() lib_sparql.QueryToGraph(grph, sparql_query, lib_sparql_callback_survol.SurvolCallbackAp()) # At this stage, we must run the Sparql query on the generated RDF triplestore. envSparql.WriteTripleStoreAsString(grph)
def Main(): lib_util.SetLoggingConfig(logging.ERROR) envSparql = lib_sparql.SparqlEnvironment() grph = lib_kbase.MakeGraph() sparql_query = envSparql.Query() lib_sparql.QueryToGraph(grph, sparql_query, objectCallback) # See lib_common.py : This added to any RDF document. ###########lib_export_ontology.Grph2Rdf(grph) # At this stage, we must run the Sparql query on the generated RDF triplestore. envSparql.WriteTripleStoreAsString(grph)
def Main(): lib_util.SetLoggingConfig(logging.ERROR) # https://hhs.github.io/meshrdf/sparql-and-uri-requests # Parameter name, SELECT queries, CONSTRUCT queries, default, help. # format # Accepts HTML*, XML, CSV, TSV or JSON # Accepts HTML*, XML, JSON-LD, RDF/XML, TURTLE or N3 # Default: HTML* # Returns a file with the specified syntax. # inference # Accepts true or false # Accepts true or false # Default: false # Running a query with inference set to "true" will return results # for all subclasses and subproperties of those classes and properties you specify in your query. # For example, there are no direct instances of meshv:Descriptor, # but if you run a query with inference and look for rdf:type meshv:Descriptor, # you will get all instances of meshv:Descriptor's subclasses - meshv:TopicalDescriptor, # meshv:GeographicalDescriptor, meshv:PublicationType and meshv:CheckTag. # Running a query with inference=true may affect performance. # limit # Accepts positive integers up to 1000 # N/A # Default: 1000 # Limits the number of results per request. The maximum number of results per request for SELECT queries is 1,000. # This parameter does not affect CONSTRUCT queries. # CONSTRUCT queries will return all triples requested up to a limit of 10,000 triples. # offset # Accepts positive integers # N/A # Default: 0 # When offset=n, this parameter will return results starting with the nth result. # Use this parameter to loop through multiple requests for large result sets. # query # Accepts a SELECT SPARQL query # Accepts a CONSTRUCT SPARQL query # Default: N/A # This parameter is required and must contain a SPARQL query. For an example of how these are formatted, # run a query from the SPARQL query editor and view the resulting URL. # year # Accepts "current" or a year. # Accepts "current" or a year. # Default: current # Queries either the current MeSH graph (http://id.nlm.nih.gov/mesh) or a versioned MeSH graph, # for example: (http://id.nlm.nih.gov/mesh/2015). import cgi arguments = cgi.FieldStorage() # See lib_uris.SmbShareUri and the HTTP server which collapses duplicated slashes "//" into one, # in URL, because they are interpreted as file names. # SparqlWrapper does not encode slashes with urllib.quote_plus(param.encode('UTF-8'), safe='/') # in Wrapper.py. # See modules CGIHTTPServer, BaseHTTPServer, CGIHTTPRequestHandler # 'HTTP_USER_AGENT': 'sparqlwrapper 1.8.4 (rdflib.github.io/sparqlwrapper)' # sys.stderr.write("Environ=%s\n"%str(os.environ)) # QUERY_STRING='query=%0A++++++++++++++++PREFIX+wmi%3A++%3Chttp%3A/www.primhillcomputers.com/ontology/wmi%23%3E%0A++++++++++++++++PREFIX+survol%3A++%3Chttp%3A/primhillcomputers.com/survol%23%3E%0A++++++++++++++++PREFIX+rdfs%3A++++%3Chttp%3A/www.w3.org/2000/01/rdf-schema% # 23%3E%0A++++++++++++++++SELECT+%3Fcaption%0A++++++++++++++++WHERE%0A++++++++++++++++%7B%0A++++++++++++++++++++%3Furl_user+rdf%3Atype+survol%3AWin32_UserAccount+.%0A++++++++++++++++++++%3Furl_user+survol%3AName+%27rchateau%27+.%0A++++++++++++++++++++%3Furl_user+sur # vol%3ACaption+%3Fcaption+.%0A++++++++++++++++++++%3Furl_user+rdfs%3AseeAlso+%22WMI%22+.%0A++++++++++++++++%7D%0A++++++++++++++++&output=json&results=json&format=json' sparql_query = arguments["query"].value # 'SERVER_SOFTWARE': 'SimpleHTTP/0.6 Python/2.7.10' # 'SERVER_SOFTWARE': 'SimpleHTTP/0.6 Python/3.6.3' sys.stderr.write("SERVER_SOFTWARE=%s\n" % os.environ['SERVER_SOFTWARE']) if os.environ['SERVER_SOFTWARE'].startswith("SimpleHTTP"): # Beware, only with Python2. Not needed on Linux and Python 3. # Maybe because the Python class processes the CGI arguments like filenames. if not lib_util.is_py3 and lib_util.isPlatformWindows: sparql_query = re.sub("([^a-z]*)http:/([^a-z]*)", r"\1http://\2", sparql_query) sys.stderr.write("Substitution 'http://' and 'http:///'\n") sys.stderr.write("sparql_server sparql_query=%s\n" % sparql_query.replace(" ","=")) try: result_format = arguments["format"].value except KeyError: result_format = "HTML*" sys.stderr.write("\n") query_result = __run_sparql_query(sparql_query) sys.stderr.write("sparql_server After query len(query_result)=%d\n" % len(query_result)) sys.stderr.write("sparql_server After query query_result=%s\n" % str(query_result)) # TODO: This does not work "select *", so maybe should read the first row. row_header = __query_header(sparql_query) # https://docs.aws.amazon.com/neptune/latest/userguide/sparql-api-reference-mime.html if result_format.upper() == "JSON": mime_format = "application/sparql-results+json" # https://www.w3.org/TR/2013/REC-sparql11-results-json-20130321/ # This document describes how to serialize SPARQL results (SELECT and ASK query forms) in a JSON format. # { # "head": {"vars": ["book", "title"] # }, # "results": { # "bindings": [ # { # "book": {"type": "uri", "value": "http://example.org/book/book6"}, # "title": {"type": "literal", "value": "Harry Potter and the Half-Blood Prince"} # }, bindings_list = [] for one_row in query_result: dict_row = {} for ix in range(len(row_header)): one_element = one_row[ix] if lib_kbase.IsLiteral(one_element): json_element = {"type":"literal", "value": str(one_element)} elif lib_kbase.IsURIRef(one_element): json_element = {"type":"url", "value": str(one_element)} else: raise Exception("SparqlServer: Invalid type:%s"%str(one_element)) one_variable = row_header[ix] dict_row[one_variable] = json_element bindings_list.append(dict_row) sys.stderr.write("bindings_list=%s\n"%str(bindings_list)) json_output = { "head": {"vars": row_header}, "results": {"bindings": bindings_list}} str_output = json.dumps(json_output) elif result_format.upper() == "XML": mime_format = "application/sparql-results+xml" # https://www.w3.org/TR/rdf-sparql-XMLres/ # This document describes an XML format for the variable binding and boolean results formats provided by the SPARQL query language for RDF # <?xml version="1.0"?> # <sparql xmlns="http://www.w3.org/2005/sparql-results#"> # <head> # <variable name="x"/> # <variable name="hpage"/> # </head> # # <results> # <result> # <binding name="x"> ... </binding> # <binding name="hpage"> ... </binding> # </result> root = ET.Element("sparql") head = ET.SubElement(root, "head") for one_variable in row_header: ET.SubElement(head, "variable", name=one_variable) results = ET.SubElement(root, "results") for one_row in query_result: result = ET.SubElement(results, "result") for ix in range(len(row_header)): one_variable = row_header[ix] ET.SubElement(result, "binding", name=one_variable).text = one_row[ix] str_output = ET.tostring(root, encoding='utf8', method='xml') sys.stderr.write("sparql_server str_output=%s\n"%str_output) else: raise Exception("Results format %s not implemented yet"%result_format) sys.stderr.write("sparql_server result_format=%s str_output=%s\n"%(result_format, str_output)) lib_util.WrtHeader(mime_format) lib_util.WrtAsUtf(str_output)
import lib_util import lib_common import lib_kbase import lib_sparql import lib_wmi import lib_wbem import lib_sparql_custom_evals # For the moment, it just displays the content of the input to standard error, # so the SparQL protocol can be analysed. # See Experimental/Test_package_sparqlwrapper.py # http://timgolden.me.uk/python/downloads/wmi-0.6b.py lib_util.SetLoggingConfig(logging.DEBUG) def __run_sparql_query(sparql_query): grph = lib_kbase.MakeGraph() # add function directly, normally we would use setuptools and entry_points rdflib.plugins.sparql.CUSTOM_EVALS['custom_eval_function'] = lib_sparql_custom_evals.custom_eval_function query_result = grph.query(sparql_query) if 'custom_eval_function' in rdflib.plugins.sparql.CUSTOM_EVALS: del rdflib.plugins.sparql.CUSTOM_EVALS['custom_eval_function'] return query_result ################################################################################ def __query_header(sparql_query): parsed = rdflib.plugins.sparql.parser.parseQuery(sparql_query)