`/:data:`N3`, a string is returned
* in the case of :data:`CSV`/:data:`TSV`, a string is returned
* In all other cases the input simply returned.
:return: the converted query result. See the conversion methods for more details.
"""
def _content_type_in_list(real, expected):
""" Internal method for checking if the content-type header received matches any of the content types of the expected list.
:param real: The content-type header received.
:type real: string
:param expected: A list of expected content types.
:type expected: list
:return: Returns a boolean after checking if the content-type header received matches any of the content types of the expected list.
:rtype: boolean
"""
return True in [real.find(mime) != -1 for mime in expected]
def _validate_format(format_name, allowed, mime, requested):
""" Internal method for validating if the requested format is one of the allowed formats.
:param format_name: The format name (to be used in the warning message).
:type format_name: string
:param allowed: A list of allowed content types.
:type allowed: list
:param mime: The content-type header received (to be used in the warning message).
:type mime: string
:param requested: the requested format.
:type requested: string
"""
if requested not in allowed:
message = "Format requested was %s, but %s (%s) has been returned by the endpoint"
warnings.warn(message % (requested.upper(), format_name, mime), RuntimeWarning)
# TODO. In order to compare properly, the requested QueryType (SPARQL Query Form) is needed. For instance, the unexpected N3 requested for a SELECT would return XML
if "content-type" in self.info():
ct = self.info()["content-type"] # returned Content-Type value
if _content_type_in_list(ct, _SPARQL_XML):
_validate_format("XML", [XML], ct, self.requestedFormat)
return self._convertXML()
elif _content_type_in_list(ct, _XML):
_validate_format("XML", [XML], ct, self.requestedFormat)
return self._convertXML()
elif _content_type_in_list(ct, _SPARQL_JSON):
_validate_format("JSON", [JSON], ct, self.requestedFormat)
return self._convertJSON()
elif _content_type_in_list(ct, _RDF_XML):
_validate_format("RDF/XML", [RDF, XML, RDFXML], ct, self.requestedFormat)
return self._convertRDF()
elif _content_type_in_list(ct, _RDF_N3):
_validate_format("N3", [N3, TURTLE], ct, self.requestedFormat)
return self._convertN3()
elif _content_type_in_list(ct, _CSV):
_validate_format("CSV", [CSV], ct, self.requestedFormat)
return self._convertCSV()
elif _content_type_in_list(ct, _TSV):
_validate_format("TSV", [TSV], ct, self.requestedFormat)
return self._convertTSV()
elif _content_type_in_list(ct, _RDF_JSONLD):
_validate_format("JSON(-LD)", [JSONLD, JSON], ct, self.requestedFormat)
return self._convertJSONLD()
else:
warnings.warn("unknown response content type '%s' returning raw response..." %(ct), RuntimeWarning)
return self.response.read()
def _get_responseFormat(self):
"""
Get the response (return) format. The possible values are: :data:`JSON`, :data:`XML`, :data:`RDFXML`, :data:`TURTLE`, :data:`N3`, :data:`CSV`, :data:`TSV`, :data:`JSONLD`.
In case there is no Content-Type, ``None`` is return. In all other cases, the raw Content-Type is return.
.. versionadded:: 1.8.3
:return: the response format. The possible values are: :data:`JSON`, :data:`XML`, :data:`RDFXML`, :data:`TURTLE`, :data:`N3`, :data:`CSV`, :data:`TSV`, :data:`JSONLD`.
:rtype: string
"""
def _content_type_in_list(real, expected):
""" Internal method for checking if the content-type header received matches any of the content types of the expected list.
:param real: The content-type header received.
:type real: string
:param expected: A list of expected content types.
:type expected: list
:return: Returns a boolean after checking if the content-type header received matches any of the content types of the expected list.
:rtype: boolean
"""
return True in [real.find(mime) != -1 for mime in expected]
if "content-type" in self.info():
ct = self.info()["content-type"] # returned Content-Type value
if _content_type_in_list(ct, _SPARQL_XML):
return XML
elif _content_type_in_list(ct, _XML):
return XML
elif _content_type_in_list(ct, _SPARQL_JSON):
return JSON
elif _content_type_in_list(ct, _RDF_XML):
return RDFXML
elif _content_type_in_list(ct, _RDF_TURTLE):
return TURTLE
elif _content_type_in_list(ct, _RDF_N3):
return N3
elif _content_type_in_list(ct, _CSV):
return CSV
elif _content_type_in_list(ct, _TSV):
return TSV
elif _content_type_in_list(ct, _RDF_JSONLD):
return JSONLD
else:
warnings.warn("Unknown response content type. Returning raw content-type ('%s')." %(ct), RuntimeWarning)
return ct
return None
def print_results(self, minWidth=None):
"""This method prints a representation of a :class:`QueryResult` object that MUST has as response format :data:`JSON`.
:param minWidth: The minimum width, counting as characters. The default value is ``None``.
:type minWidth: string
"""
# Check if the requested format was JSON. If not, exit.
responseFormat = self._get_responseFormat()
if responseFormat != JSON:
message = "Format return was %s, but JSON was expected. No printing."
warnings.warn(message % (responseFormat), RuntimeWarning)
return
results = self._convertJSON()
if minWidth:
width = self.__get_results_width(results, minWidth)
else:
width = self.__get_results_width(results)
index = 0
for var in results["head"]["vars"]:
print ("?" + var).ljust(width[index]), "|",
index += 1
print
print "=" * (sum(width) + 3 * len(width))
for result in results["results"]["bindings"]:
index = 0
for var in results["head"]["vars"]:
result_value = self.__get_prettyprint_string_sparql_var_result(result[var])
print result_value.ljust(width[index]), "|",
index += 1
print
def __get_results_width(self, results, minWidth=2):
width = []
for var in results["head"]["vars"]:
width.append(max(minWidth, len(var)+1))
for result in results["results"]["bindings"]:
index = 0
for var in results["head"]["vars"]:
result_value = self.__get_prettyprint_string_sparql_var_result(result[var])
width[index] = max(width[index], len(result_value))
index += 1
return width
def __get_prettyprint_string_sparql_var_result(self, result):
value = result["value"]
lang = result.get("xml:lang", None)
datatype = result.get("datatype", None)
if lang is not None:
value += "@"+lang
if datatype is not None:
value += " ["+datatype+"]"
return value
def __str__(self):
"""This method returns the string representation of a :class:`QueryResult` object.
:return: A human-readable string of the object.
:rtype: string
.. versionadded:: 1.8.3
"""
fullname = self.__module__ + "." + self.__class__.__name__
str_requestedFormat = '"requestedFormat" : '+repr(self.requestedFormat)
str_url = self.response.url
str_code = self.response.code
str_headers = self.response.info()
str_response = '"response (a file-like object, as return by the urllib2.urlopen library call)" : {\n\t"url" : "%s",\n\t"code" : "%s",\n\t"headers" : %s}' % (str_url, str_code, str_headers)
return "<%s object at 0x%016X>\n{%s,\n%s}" % (fullname, id(self), str_requestedFormat, str_response)
sparqlwrapper-1.8.5/SPARQLWrapper/__init__.py 0000664 0000000 0000000 00000002467 13577650276 0021137 0 ustar 00root root 0000000 0000000 # -*- coding: utf8 -*-
u"""
**SPARQLWrapper** is a simple Python wrapper around a `SPARQL `_ service to
remotelly execute your queries. It helps in creating the query
invokation and, possibly, convert the result into a more manageable
format.
"""
__version__ = "1.8.5"
"""The version of SPARQLWrapper"""
__authors__ = "Ivan Herman, Sergio Fernández, Carlos Tejo Alonso, Alexey Zakhlestin"
"""The primary authors of SPARQLWrapper"""
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/copyright-software"
"""The license governing the use and distribution of SPARQLWrapper"""
__url__ = "http://rdflib.github.io/sparqlwrapper"
"""The URL for SPARQLWrapper's homepage"""
__contact__ = "rdflib-dev@googlegroups.com"
"""Mail list to contact to other people RDFLib and SPARQLWrappers folks and developers"""
__date__ = "2019-04-18"
"""Last update"""
__agent__ = "sparqlwrapper %s (rdflib.github.io/sparqlwrapper)" % __version__
from Wrapper import SPARQLWrapper
from Wrapper import XML, JSON, TURTLE, N3, JSONLD, RDF, RDFXML, CSV, TSV
from Wrapper import GET, POST
from Wrapper import SELECT, CONSTRUCT, ASK, DESCRIBE, INSERT, DELETE
from Wrapper import URLENCODED, POSTDIRECTLY
from Wrapper import BASIC, DIGEST
from SmartWrapper import SPARQLWrapper2
sparqlwrapper-1.8.5/custom_fixers/ 0000775 0000000 0000000 00000000000 13577650276 0017344 5 ustar 00root root 0000000 0000000 sparqlwrapper-1.8.5/custom_fixers/__init__.py 0000775 0000000 0000000 00000000000 13577650276 0021446 0 ustar 00root root 0000000 0000000 sparqlwrapper-1.8.5/custom_fixers/fix_urllib2.py 0000775 0000000 0000000 00000000643 13577650276 0022145 0 ustar 00root root 0000000 0000000 from lib2to3.fixer_base import BaseFix
from lib2to3.fixer_util import Name
class FixUrllib2(BaseFix):
PATTERN = "power< fixprefix='urllib2' trailer< '.' '_opener' > >|power< fixprefix='urllib2' trailer< '.' '_opener' > trailer< '.' handlers='handlers' > >"
def transform(self, node, results):
fixprefix = results['fixprefix']
fixprefix.replace(Name('urllib.request', prefix=fixprefix.prefix))
sparqlwrapper-1.8.5/docs/ 0000775 0000000 0000000 00000000000 13577650276 0015402 5 ustar 00root root 0000000 0000000 sparqlwrapper-1.8.5/docs/Makefile 0000664 0000000 0000000 00000001362 13577650276 0017044 0 ustar 00root root 0000000 0000000 # Minimal makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
SOURCEDIR = source
BUILDDIR = build
# Put it first so that "make" without argument is like "make help".
help:
@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
.PHONY: help Makefile
# Catch-all target: route all unknown targets to Sphinx using the new
# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
%: Makefile
@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
buildapi:
sphinx-apidoc -fMe ../SPARQLWrapper/ -o source/
@echo "Auto-generation of SPARQLWrapper documentation finished. " \
"The generated files are in 'source/'"
sparqlwrapper-1.8.5/docs/make.bat 0000664 0000000 0000000 00000001364 13577650276 0017013 0 ustar 00root root 0000000 0000000 @ECHO OFF
pushd %~dp0
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set SOURCEDIR=source
set BUILDDIR=build
if "%1" == "" goto help
%SPHINXBUILD% >NUL 2>NUL
if errorlevel 9009 (
echo.
echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
echo.installed, then set the SPHINXBUILD environment variable to point
echo.to the full path of the 'sphinx-build' executable. Alternatively you
echo.may add the Sphinx directory to PATH.
echo.
echo.If you don't have Sphinx installed, grab it from
echo.http://sphinx-doc.org/
exit /b 1
)
%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
goto end
:help
%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
:end
popd
sparqlwrapper-1.8.5/docs/source/ 0000775 0000000 0000000 00000000000 13577650276 0016702 5 ustar 00root root 0000000 0000000 sparqlwrapper-1.8.5/docs/source/SPARQLWrapper.KeyCaseInsensitiveDict.rst 0000664 0000000 0000000 00000000307 13577650276 0026347 0 ustar 00root root 0000000 0000000 SPARQLWrapper.KeyCaseInsensitiveDict module
===========================================
.. automodule:: SPARQLWrapper.KeyCaseInsensitiveDict
:members:
:undoc-members:
:show-inheritance:
sparqlwrapper-1.8.5/docs/source/SPARQLWrapper.SPARQLExceptions.rst 0000664 0000000 0000000 00000000174 13577650276 0025044 0 ustar 00root root 0000000 0000000 SPARQLWrapper.SPARQLExceptions module
=====================================
.. automodule:: SPARQLWrapper.SPARQLExceptions
sparqlwrapper-1.8.5/docs/source/SPARQLWrapper.SmartWrapper.rst 0000664 0000000 0000000 00000000220 13577650276 0024417 0 ustar 00root root 0000000 0000000 SPARQLWrapper.SmartWrapper module
=================================
.. automodule:: SPARQLWrapper.SmartWrapper
:member-order: alphabetical
sparqlwrapper-1.8.5/docs/source/SPARQLWrapper.Wrapper.rst 0000664 0000000 0000000 00000000173 13577650276 0023417 0 ustar 00root root 0000000 0000000 SPARQLWrapper.Wrapper module
============================
.. automodule:: SPARQLWrapper.Wrapper
:no-show-inheritance:
sparqlwrapper-1.8.5/docs/source/_templates/ 0000775 0000000 0000000 00000000000 13577650276 0021037 5 ustar 00root root 0000000 0000000 sparqlwrapper-1.8.5/docs/source/_templates/globaltocindex.html 0000664 0000000 0000000 00000000445 13577650276 0024726 0 ustar 00root root 0000000 0000000 {#
basic/globaltoc.html
~~~~~~~~~~~~~~~~~~~~
Sphinx sidebar template: global table of contents.
:copyright: Copyright 2007-2017 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
Modified to work properly with the index page
#}
{{ toctree() }}
sparqlwrapper-1.8.5/docs/source/_templates/localtocindex.html 0000664 0000000 0000000 00000000614 13577650276 0024556 0 ustar 00root root 0000000 0000000 {#
basic/localtoc.html
~~~~~~~~~~~~~~~~~~~
Sphinx sidebar template: local table of contents.
:copyright: Copyright 2007-2017 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
Modified to work properly with the index page
#}
{%- if display_toc %}
{{ toc }}
{%- endif %}
sparqlwrapper-1.8.5/docs/source/_templates/sidebarhelp.html 0000664 0000000 0000000 00000000254 13577650276 0024210 0 ustar 00root root 0000000 0000000 Need help?
Open an issue in our issue
tracker. Issues that are just questions are fine.
sparqlwrapper-1.8.5/docs/source/changelog.rst 0000664 0000000 0000000 00000000043 13577650276 0021360 0 ustar 00root root 0000000 0000000
.. include:: ../../ChangeLog.txt
sparqlwrapper-1.8.5/docs/source/conf.py 0000664 0000000 0000000 00000015402 13577650276 0020203 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/master/config
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
sys.path.insert(0, os.path.abspath('../..'))
sys.path.insert(0, os.path.abspath('../../SPARQLWrapper')) # from https://stackoverflow.com/questions/10324393/sphinx-build-fail-autodoc-cant-import-find-module
from SPARQLWrapper import __version__
# -- Project information -----------------------------------------------------
project = u'SPARQLWrapper'
copyright = u'2019, `W3C® SOFTWARE NOTICE AND LICENSE `_'
author = u'Ivan Herman'
author = u'Sergio Fernández'
author = u'Carlos Tejo Alonso'
author = u'Alexey Zakhlestin'
# The short X.Y version
version = __version__
# The full version, including alpha/beta/rc tags
#release = u'1.8.5.dev0'
# -- General configuration ---------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.autosummary',
'sphinx.ext.doctest',
'sphinx.ext.intersphinx',
'sphinx.ext.todo',
'sphinx.ext.coverage',
'sphinx.ext.viewcode',
'sphinx.ext.githubpages',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
exclude_patterns = []
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = None
autodoc_member_order = 'bysource'
autodoc_default_options = {
'members': None,
'private-members': None,
'show-inheritance': None,
'special-members': '__init__'
}
autoclass_content = 'class'
#autosummary_generate = True
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'sphinx_rtd_theme'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {
# Toc options
'collapse_navigation': False,
'sticky_navigation': True,
'navigation_depth': 4,
'includehidden': True,
'titles_only': False
}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
#html_static_path = ['_static']
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# The default sidebars (for documents that don't match any pattern) are
# defined by theme itself. Builtin themes are using these templates by
# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
# 'searchbox.html']``.
#
# html_sidebars = {
# '**': ['globaltoc.html', 'sidebarhelp.html',
# 'searchbox.html'],
# 'index': ['localtocindex.html', 'globaltocindex.html', 'sidebarhelp.html',
# 'searchbox.html'],
# }
# -- Options for HTMLHelp output ---------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = 'SPARQLWrapperdoc'
html_show_copyright = False
html_show_sphinx = False
# -- Options for LaTeX output ------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'SPARQLWrapper.tex', u'SPARQLWrapper Documentation',
u'CHANGE\\_AUTHORS', 'manual'),
]
# -- Options for manual page output ------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'sparqlwrapper', u'SPARQLWrapper Documentation',
[author], 1)
]
# -- Options for Texinfo output ----------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'SPARQLWrapper', u'SPARQLWrapper Documentation',
author, 'SPARQLWrapper', 'One line description of project.',
'Miscellaneous'),
]
# -- Options for Epub output -------------------------------------------------
# Bibliographic Dublin Core info.
epub_title = project
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#
# epub_identifier = ''
# A unique identification for the text.
#
# epub_uid = ''
# A list of files that should not be packed into the epub file.
epub_exclude_files = ['search.html']
# -- Extension configuration -------------------------------------------------
# -- Options for intersphinx extension ---------------------------------------
# Example configuration for intersphinx: refer to the Python standard library.
intersphinx_mapping = {
'https://docs.python.org/2/': None,
}
# -- Options for todo extension ----------------------------------------------
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = True
sparqlwrapper-1.8.5/docs/source/index.rst 0000664 0000000 0000000 00000001637 13577650276 0020552 0 ustar 00root root 0000000 0000000 =======================================
SPARQL Endpoint interface to Python
=======================================
|Build Status| |PyPi version|
**SPARQLWrapper** is a simple Python wrapper around a `SPARQL `_ service to
remotelly execute your queries. It helps in creating the query
invokation and, possibly, convert the result into a more manageable
format.
.. toctree::
:hidden:
:caption: Basic steps
main
.. toctree::
:hidden:
:caption: Python Package
modules
ChangeLog
Indices and tables
==================
* :ref:`genindex`
* :ref:`modindex`
* :ref:`search`
.. |Build Status| image:: https://secure.travis-ci.org/RDFLib/sparqlwrapper.svg?branch=master
:target: https://travis-ci.org/RDFLib/sparqlwrapper
.. |PyPi version| image:: https://badge.fury.io/py/SPARQLWrapper.svg
:target: https://pypi.python.org/pypi/SPARQLWrapper sparqlwrapper-1.8.5/docs/source/main.rst 0000664 0000000 0000000 00000000040 13577650276 0020352 0 ustar 00root root 0000000 0000000
.. include:: ../../README.rst
sparqlwrapper-1.8.5/docs/source/modules.rst 0000664 0000000 0000000 00000000275 13577650276 0021110 0 ustar 00root root 0000000 0000000 SPARQLWrapper package
=====================
.. toctree::
SPARQLWrapper.Wrapper
SPARQLWrapper.SmartWrapper
SPARQLWrapper.SPARQLExceptions
SPARQLWrapper.KeyCaseInsensitiveDict
sparqlwrapper-1.8.5/ez_setup.py 0000664 0000000 0000000 00000024055 13577650276 0016670 0 ustar 00root root 0000000 0000000 #!python
"""Bootstrap setuptools installation
If you want to use setuptools in your package's setup.py, just include this
file in the same directory with it, and add this to the top of your setup.py::
from ez_setup import use_setuptools
use_setuptools()
If you want to require a specific version of setuptools, set a download
mirror, or use an alternate download directory, you can do so by supplying
the appropriate options to ``use_setuptools()``.
This file can also be run as a script to install or upgrade setuptools.
"""
import sys
DEFAULT_VERSION = "0.6c11"
DEFAULT_URL = "http://pypi.python.org/packages/%s/s/setuptools/" % sys.version[:3]
md5_data = {
'setuptools-0.6b1-py2.3.egg': '8822caf901250d848b996b7f25c6e6ca',
'setuptools-0.6b1-py2.4.egg': 'b79a8a403e4502fbb85ee3f1941735cb',
'setuptools-0.6b2-py2.3.egg': '5657759d8a6d8fc44070a9d07272d99b',
'setuptools-0.6b2-py2.4.egg': '4996a8d169d2be661fa32a6e52e4f82a',
'setuptools-0.6b3-py2.3.egg': 'bb31c0fc7399a63579975cad9f5a0618',
'setuptools-0.6b3-py2.4.egg': '38a8c6b3d6ecd22247f179f7da669fac',
'setuptools-0.6b4-py2.3.egg': '62045a24ed4e1ebc77fe039aa4e6f7e5',
'setuptools-0.6b4-py2.4.egg': '4cb2a185d228dacffb2d17f103b3b1c4',
'setuptools-0.6c1-py2.3.egg': 'b3f2b5539d65cb7f74ad79127f1a908c',
'setuptools-0.6c1-py2.4.egg': 'b45adeda0667d2d2ffe14009364f2a4b',
'setuptools-0.6c10-py2.3.egg': 'ce1e2ab5d3a0256456d9fc13800a7090',
'setuptools-0.6c10-py2.4.egg': '57d6d9d6e9b80772c59a53a8433a5dd4',
'setuptools-0.6c10-py2.5.egg': 'de46ac8b1c97c895572e5e8596aeb8c7',
'setuptools-0.6c10-py2.6.egg': '58ea40aef06da02ce641495523a0b7f5',
'setuptools-0.6c11-py2.3.egg': '2baeac6e13d414a9d28e7ba5b5a596de',
'setuptools-0.6c11-py2.4.egg': 'bd639f9b0eac4c42497034dec2ec0c2b',
'setuptools-0.6c11-py2.5.egg': '64c94f3bf7a72a13ec83e0b24f2749b2',
'setuptools-0.6c11-py2.6.egg': 'bfa92100bd772d5a213eedd356d64086',
'setuptools-0.6c2-py2.3.egg': 'f0064bf6aa2b7d0f3ba0b43f20817c27',
'setuptools-0.6c2-py2.4.egg': '616192eec35f47e8ea16cd6a122b7277',
'setuptools-0.6c3-py2.3.egg': 'f181fa125dfe85a259c9cd6f1d7b78fa',
'setuptools-0.6c3-py2.4.egg': 'e0ed74682c998bfb73bf803a50e7b71e',
'setuptools-0.6c3-py2.5.egg': 'abef16fdd61955514841c7c6bd98965e',
'setuptools-0.6c4-py2.3.egg': 'b0b9131acab32022bfac7f44c5d7971f',
'setuptools-0.6c4-py2.4.egg': '2a1f9656d4fbf3c97bf946c0a124e6e2',
'setuptools-0.6c4-py2.5.egg': '8f5a052e32cdb9c72bcf4b5526f28afc',
'setuptools-0.6c5-py2.3.egg': 'ee9fd80965da04f2f3e6b3576e9d8167',
'setuptools-0.6c5-py2.4.egg': 'afe2adf1c01701ee841761f5bcd8aa64',
'setuptools-0.6c5-py2.5.egg': 'a8d3f61494ccaa8714dfed37bccd3d5d',
'setuptools-0.6c6-py2.3.egg': '35686b78116a668847237b69d549ec20',
'setuptools-0.6c6-py2.4.egg': '3c56af57be3225019260a644430065ab',
'setuptools-0.6c6-py2.5.egg': 'b2f8a7520709a5b34f80946de5f02f53',
'setuptools-0.6c7-py2.3.egg': '209fdf9adc3a615e5115b725658e13e2',
'setuptools-0.6c7-py2.4.egg': '5a8f954807d46a0fb67cf1f26c55a82e',
'setuptools-0.6c7-py2.5.egg': '45d2ad28f9750e7434111fde831e8372',
'setuptools-0.6c8-py2.3.egg': '50759d29b349db8cfd807ba8303f1902',
'setuptools-0.6c8-py2.4.egg': 'cba38d74f7d483c06e9daa6070cce6de',
'setuptools-0.6c8-py2.5.egg': '1721747ee329dc150590a58b3e1ac95b',
'setuptools-0.6c9-py2.3.egg': 'a83c4020414807b496e4cfbe08507c03',
'setuptools-0.6c9-py2.4.egg': '260a2be2e5388d66bdaee06abec6342a',
'setuptools-0.6c9-py2.5.egg': 'fe67c3e5a17b12c0e7c541b7ea43a8e6',
'setuptools-0.6c9-py2.6.egg': 'ca37b1ff16fa2ede6e19383e7b59245a',
}
import sys, os
try: from hashlib import md5
except ImportError: from md5 import md5
def _validate_md5(egg_name, data):
if egg_name in md5_data:
digest = md5(data).hexdigest()
if digest != md5_data[egg_name]:
print >>sys.stderr, (
"md5 validation of %s failed! (Possible download problem?)"
% egg_name
)
sys.exit(2)
return data
def use_setuptools(
version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
download_delay=15
):
"""Automatically find/download setuptools and make it available on sys.path
`version` should be a valid setuptools version number that is available
as an egg for download under the `download_base` URL (which should end with
a '/'). `to_dir` is the directory where setuptools will be downloaded, if
it is not already available. If `download_delay` is specified, it should
be the number of seconds that will be paused before initiating a download,
should one be required. If an older version of setuptools is installed,
this routine will print a message to ``sys.stderr`` and raise SystemExit in
an attempt to abort the calling script.
"""
was_imported = 'pkg_resources' in sys.modules or 'setuptools' in sys.modules
def do_download():
egg = download_setuptools(version, download_base, to_dir, download_delay)
sys.path.insert(0, egg)
import setuptools; setuptools.bootstrap_install_from = egg
try:
import pkg_resources
except ImportError:
return do_download()
try:
pkg_resources.require("setuptools>="+version); return
except pkg_resources.VersionConflict, e:
if was_imported:
print >>sys.stderr, (
"The required version of setuptools (>=%s) is not available, and\n"
"can't be installed while this script is running. Please install\n"
" a more recent version first, using 'easy_install -U setuptools'."
"\n\n(Currently using %r)"
) % (version, e.args[0])
sys.exit(2)
else:
del pkg_resources, sys.modules['pkg_resources'] # reload ok
return do_download()
except pkg_resources.DistributionNotFound:
return do_download()
def download_setuptools(
version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
delay = 15
):
"""Download setuptools from a specified location and return its filename
`version` should be a valid setuptools version number that is available
as an egg for download under the `download_base` URL (which should end
with a '/'). `to_dir` is the directory where the egg will be downloaded.
`delay` is the number of seconds to pause before an actual download attempt.
"""
import urllib2, shutil
egg_name = "setuptools-%s-py%s.egg" % (version,sys.version[:3])
url = download_base + egg_name
saveto = os.path.join(to_dir, egg_name)
src = dst = None
if not os.path.exists(saveto): # Avoid repeated downloads
try:
from distutils import log
if delay:
log.warn("""
---------------------------------------------------------------------------
This script requires setuptools version %s to run (even to display
help). I will attempt to download it for you (from
%s), but
you may need to enable firewall access for this script first.
I will start the download in %d seconds.
(Note: if this machine does not have network access, please obtain the file
%s
and place it in this directory before rerunning this script.)
---------------------------------------------------------------------------""",
version, download_base, delay, url
); from time import sleep; sleep(delay)
log.warn("Downloading %s", url)
src = urllib2.urlopen(url)
# Read/write all in one block, so we don't create a corrupt file
# if the download is interrupted.
data = _validate_md5(egg_name, src.read())
dst = open(saveto,"wb"); dst.write(data)
finally:
if src: src.close()
if dst: dst.close()
return os.path.realpath(saveto)
def main(argv, version=DEFAULT_VERSION):
"""Install or upgrade setuptools and EasyInstall"""
try:
import setuptools
except ImportError:
egg = None
try:
egg = download_setuptools(version, delay=0)
sys.path.insert(0,egg)
from setuptools.command.easy_install import main
return main(list(argv)+[egg]) # we're done here
finally:
if egg and os.path.exists(egg):
os.unlink(egg)
else:
if setuptools.__version__ == '0.0.1':
print >>sys.stderr, (
"You have an obsolete version of setuptools installed. Please\n"
"remove it from your system entirely before rerunning this script."
)
sys.exit(2)
req = "setuptools>="+version
import pkg_resources
try:
pkg_resources.require(req)
except pkg_resources.VersionConflict:
try:
from setuptools.command.easy_install import main
except ImportError:
from easy_install import main
main(list(argv)+[download_setuptools(delay=0)])
sys.exit(0) # try to force an exit
else:
if argv:
from setuptools.command.easy_install import main
main(argv)
else:
print "Setuptools version",version,"or greater has been installed."
print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)'
def update_md5(filenames):
"""Update our built-in md5 registry"""
import re
for name in filenames:
base = os.path.basename(name)
f = open(name,'rb')
md5_data[base] = md5(f.read()).hexdigest()
f.close()
data = [" %r: %r,\n" % it for it in md5_data.items()]
data.sort()
repl = "".join(data)
import inspect
srcfile = inspect.getsourcefile(sys.modules[__name__])
f = open(srcfile, 'rb'); src = f.read(); f.close()
match = re.search("\nmd5_data = {\n([^}]+)}", src)
if not match:
print >>sys.stderr, "Internal error!"
sys.exit(2)
src = src[:match.start(1)] + repl + src[match.end(1):]
f = open(srcfile,'w')
f.write(src)
f.close()
if __name__=='__main__':
if len(sys.argv)>2 and sys.argv[1]=='--md5update':
update_md5(sys.argv[2:])
else:
main(sys.argv[1:])
sparqlwrapper-1.8.5/requirements.development.txt 0000664 0000000 0000000 00000000047 13577650276 0022260 0 ustar 00root root 0000000 0000000 nose>=1.3.7
2to3>=1.0
setuptools>=3.7.1 sparqlwrapper-1.8.5/requirements.txt 0000664 0000000 0000000 00000000014 13577650276 0017731 0 ustar 00root root 0000000 0000000 rdflib>=4.0
sparqlwrapper-1.8.5/run_tests_py3.sh 0000775 0000000 0000000 00000002331 13577650276 0017631 0 ustar 00root root 0000000 0000000 #!/bin/bash
# FOR MANUAL RUNNING, IT REQUIRES modules: 2to3, python3-setuptools, python3-nose
# REMEMBER to remove PYTHON_VERSION SUFFIX
# Please, install the required tools previously:
# $ sudo apt-get install 2to3
# $ sudo apt-get install python3-setuptools
# $ sudo apt-get install python3-nose
function cmdcheck() {
command -v $1 >/dev/null 2>&1 || { echo >&2 "ERROR: command $1 required but it's not installed; aborting..."; exit -1; }
}
cmdcheck python3
PYTHON_VERSION=`python3 -c "import sys;t='{v[0]}.{v[1]}'.format(v=list(sys.version_info[:2]));sys.stdout.write(t)";`
#cmdcheck 2to3-$PYTHON_VERSION
#cmdcheck nosetests-$PYTHON_VERSION
#cmdcheck nosetests3
python3 setup.py build
if [ -d build/py3_testing ]; then
rm -r build/py3_testing
echo "removed build/py3_testing directory from previous run"
fi
mkdir build/py3_testing
cp -r test build/py3_testing/
cp -r build/lib/SPARQLWrapper build/py3_testing/
cd build/py3_testing
if command -v 2to3-$PYTHON_VERSION; then
2to3-$PYTHON_VERSION -wn --no-diffs test
else
2to3 -wn --no-diffs test
fi
sed -i.bak s/urllib2._opener/urllib.request._opener/g test/wrapper_test.py
if hash nosetests3 2>/dev/null; then
nosetests3
else
nosetests
fi
cd ../..
sparqlwrapper-1.8.5/scripts/ 0000775 0000000 0000000 00000000000 13577650276 0016141 5 ustar 00root root 0000000 0000000 sparqlwrapper-1.8.5/scripts/example-ask.py 0000664 0000000 0000000 00000001404 13577650276 0020721 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
from SPARQLWrapper import SPARQLWrapper, JSON, XML, CSV, TSV
sparql = SPARQLWrapper("http://dbpedia.org/sparql")
sparql.setQuery("""
ASK WHERE {
rdfs:label "Asturias"@es
}
""")
# JSON example
print '\n\n*** JSON Example'
sparql.setReturnFormat(JSON)
results = sparql.query().convert()
print results
# XML example
print '\n\n*** XML Example'
sparql.setReturnFormat(XML)
results = sparql.query().convert()
print results.toxml()
# CSV example
print '\n\n*** CSV Example'
sparql.setReturnFormat(CSV)
results = sparql.query().convert()
print results
# TSV example
print '\n\n*** TSV Example'
sparql.setReturnFormat(TSV)
results = sparql.query().convert()
print results
sparqlwrapper-1.8.5/scripts/example-construct.py 0000664 0000000 0000000 00000002350 13577650276 0022170 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
from SPARQLWrapper import SPARQLWrapper, XML, N3, TURTLE, JSONLD
from rdflib import Graph
sparql = SPARQLWrapper("http://dbpedia.org/sparql")
sparql.setQuery("""
PREFIX dbo:
PREFIX schema:
CONSTRUCT {
?lang a schema:Language ;
schema:alternateName ?iso6391Code .
}
WHERE {
?lang a dbo:Language ;
dbo:iso6391Code ?iso6391Code .
FILTER (STRLEN(?iso6391Code)=2) # to filter out non-valid values
}
""")
# RDF/XML example
print '\n\n*** RDF/XML Example'
sparql.setReturnFormat(XML)
results = sparql.query().convert()
print(results.serialize(format='xml'))
# N3 example
print '\n\n*** N3 Example'
sparql.setReturnFormat(N3)
results = sparql.query().convert()
g = Graph()
g.parse(data=results, format="n3")
print(g.serialize(format='n3'))
# Turtle example
print '\n\n*** TURTLE Example'
sparql.setReturnFormat(TURTLE)
results = sparql.query().convert()
g = Graph()
g.parse(data=results, format="turtle")
print(g.serialize(format='turtle'))
# JSONLD example
print '\n\n*** JSONLD Example'
sparql.setReturnFormat(JSONLD)
results = sparql.query().convert()
print(results.serialize(format='json-ld'))
sparqlwrapper-1.8.5/scripts/example-dbpedia.py 0000664 0000000 0000000 00000001406 13577650276 0021535 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
from SPARQLWrapper import SPARQLWrapper, JSON
sparql = SPARQLWrapper("http://dbpedia.org/sparql")
sparql.setQuery("""
PREFIX rdfs:
SELECT ?label
WHERE { rdfs:label ?label }
""")
sparql.setReturnFormat(JSON)
results = sparql.query()
results.print_results()
print
sparql.setQuery("""
PREFIX rdfs:
PREFIX dbp:
SELECT ?cheese ?label
WHERE {
?cheese a ;
dbp:region ;
rdfs:label ?label .
}
""")
sparql.setReturnFormat(JSON)
results = sparql.query()
results.print_results()
sparqlwrapper-1.8.5/scripts/example-delete.py 0000664 0000000 0000000 00000000610 13577650276 0021403 0 ustar 00root root 0000000 0000000 from SPARQLWrapper import SPARQLWrapper, POST, DIGEST
sparql = SPARQLWrapper("https://example.org/sparql-auth")
sparql.setHTTPAuth(DIGEST)
sparql.setCredentials("login", "password")
sparql.setMethod(POST)
sparql.setQuery("""
WITH
DELETE
{ rdfs:label "Asturies"@ast }
""")
results = sparql.query()
print results.response.read() sparqlwrapper-1.8.5/scripts/example-describe.py 0000664 0000000 0000000 00000001632 13577650276 0021726 0 ustar 00root root 0000000 0000000 from SPARQLWrapper import SPARQLWrapper, RDFXML, N3, TURTLE, JSONLD
from rdflib import Graph
sparql = SPARQLWrapper("http://dbpedia.org/sparql")
sparql.setQuery("""
DESCRIBE
""")
# RDF/XML example
print '\n\n*** RDF/XML Example'
sparql.setReturnFormat(RDFXML)
results = sparql.query().convert()
print(results.serialize(format='xml'))
# N3 example
print '\n\n*** N3 Example'
sparql.setReturnFormat(N3)
results = sparql.query().convert()
g = Graph()
g.parse(data=results, format="n3")
print(g.serialize(format='n3'))
# Turtle example
print '\n\n*** TURTLE Example'
sparql.setReturnFormat(TURTLE)
results = sparql.query().convert()
g = Graph()
g.parse(data=results, format="turtle")
print(g.serialize(format='turtle'))
# JSONLD example
print '\n\n*** JSONLD Example'
sparql.setReturnFormat(JSONLD)
results = sparql.query().convert()
print(results.serialize(format='json-ld'))
sparqlwrapper-1.8.5/scripts/example-federated.py 0000664 0000000 0000000 00000001472 13577650276 0022073 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
from SPARQLWrapper import SPARQLWrapper, JSON
sparql = SPARQLWrapper("http://agrovoc.uniroma2.it:3030/agrovoc/sparql")
query = """
PREFIX skos:
PREFIX rdf:
SELECT ?conceptAGROVOC ?conceptGEMET ?label
WHERE {
?conceptAGROVOC rdf:type skos:Concept ;
skos:prefLabel ?label;
skos:inScheme .
FILTER (lang(?label) = 'en')
SERVICE {
?conceptGEMET skos:prefLabel ?label ;
skos:inScheme .
}
}
"""
sparql.setQuery(query)
sparql.setReturnFormat(JSON)
results = sparql.query().print_results()
sparqlwrapper-1.8.5/scripts/example-insert-using-rdflib.py 0000664 0000000 0000000 00000001743 13577650276 0024040 0 ustar 00root root 0000000 0000000 from rdflib import Graph, URIRef, Literal
from rdflib.namespace import RDFS
g = Graph()
asturias = URIRef("http://dbpedia.org/resource/Asturias")
g.add( (asturias, RDFS.label, Literal('Asturies', lang="ast") ) )
g.add( (asturias, RDFS.label, Literal('Asturias', lang="es") ) )
g.add( (asturias, RDFS.label, Literal('Asturien', lang="de") ) )
###############################################################################
triples = ""
for subject,predicate,obj in g:
triples = triples + subject.n3() + " " + predicate.n3() + " " + obj.n3() + " . \n"
query = """WITH
INSERT {"""+ triples + """}"""
###############################################################################
from SPARQLWrapper import SPARQLWrapper, POST, DIGEST
sparql = SPARQLWrapper("https://example.org/sparql-auth")
sparql.setHTTPAuth(DIGEST)
sparql.setCredentials("login", "password")
sparql.setMethod(POST)
sparql.setQuery(query)
results = sparql.query()
print results.response.read()
sparqlwrapper-1.8.5/scripts/example-insert.py 0000664 0000000 0000000 00000000611 13577650276 0021446 0 ustar 00root root 0000000 0000000 from SPARQLWrapper import SPARQLWrapper, POST, DIGEST
sparql = SPARQLWrapper("https://example.org/sparql-auth")
sparql.setHTTPAuth(DIGEST)
sparql.setCredentials("login", "password")
sparql.setMethod(POST)
sparql.setQuery("""
WITH
INSERT
{ rdfs:label "Asturies"@ast }
""")
results = sparql.query()
print results.response.read()
sparqlwrapper-1.8.5/scripts/example-optional.py 0000664 0000000 0000000 00000001362 13577650276 0021773 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
from SPARQLWrapper import SPARQLWrapper, JSON
sparql = SPARQLWrapper("http://dbpedia.org/sparql")
sparql.setQuery("""
PREFIX rdfs:
SELECT ?person ?party
WHERE { ?person
OPTIONAL { ?person ?party }
}
""")
# JSON example
print '\n\n*** JSON Example'
sparql.setReturnFormat(JSON)
results = sparql.query().convert()
for result in results["results"]["bindings"]:
if result.has_key("party"):
print "* " + result["person"]["value"] + " ** " + result["party"]["value"]
else:
print result["person"]["value"]
sparqlwrapper-1.8.5/scripts/example.py 0000664 0000000 0000000 00000002170 13577650276 0020146 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
from SPARQLWrapper import SPARQLWrapper, JSON, XML, N3, RDF, CSV, TSV
sparql = SPARQLWrapper("http://dbpedia.org/sparql")
sparql.setQuery("""
PREFIX rdfs:
SELECT ?label
WHERE { rdfs:label ?label }
""")
# JSON example
print '\n\n*** JSON Example'
sparql.setReturnFormat(JSON)
results = sparql.query().convert()
for result in results["results"]["bindings"]:
print result["label"]["value"]
# XML example
print '\n\n*** XML Example'
sparql.setReturnFormat(XML)
results = sparql.query().convert()
print results.toxml()
# N3 example
print '\n\n*** N3 Example'
sparql.setReturnFormat(N3)
results = sparql.query().convert()
print results
# RDF example
print '\n\n*** RDF Example'
sparql.setReturnFormat(RDF)
results = sparql.query().convert()
print results.serialize()
# CSV example
print '\n\n*** CSV Example'
sparql.setReturnFormat(CSV)
results = sparql.query().convert()
print results
# TSV example
print '\n\n*** TSV Example'
sparql.setReturnFormat(TSV)
results = sparql.query().convert()
print results
sparqlwrapper-1.8.5/scripts/sparql.py 0000775 0000000 0000000 00000004316 13577650276 0020024 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import getopt
from SPARQLWrapper import SPARQLWrapper2
localSparqler = "http://localhost:2020/sparql"
localVirtuoso = "http://localhost:8890/sparql"
def main(server, query, sponge=False):
sparql = SPARQLWrapper2(server)
if sponge:
sparql.addExtraURITag("should-sponge", "grab-everything")
sparql.setQuery(query)
res = sparql.query()
variables = res.variables
print "Variables:"
print variables
print
print "Bindings:"
for b in res.bindings:
for v in res.variables:
try:
val = b[v]
if val.lang:
str = "%s: %s@%s" % (v, val.value, val.lang)
elif val.datatype:
str = "%s: %s^^%s" % (v, val.value, val.datatype)
else:
str = "%s: %s" % (v, val.value)
except KeyError:
# no binding to that one...
str = "%s: <>" % v
print str.encode('utf-8')
print
# -------------------------------------------------------------------------------------------------------------
server = localSparqler
query = ""
sponge = False
usagetxt = """%s [-s] [-u url] [file]
-s: use local sparqler (default)
-v: use local virtuoso
-u url: server url
-p: issue an extra sponge for virtuoso
file: sparql query file
"""
def usage():
print usagetxt % sys.argv[0]
sys.exit(1)
if __name__ == '__main__':
if len(sys.argv) == 1:
usage()
try:
opts, args = getopt.getopt(sys.argv[1:], "shu:pv")
for o, a in opts:
if o == "-s":
server = localSparqler
elif o == "-v":
server = localVirtuoso
sponge = True
elif o == "-h":
print usage
sys.exit(0)
elif o == "-u":
server = a
elif o == "-p":
sponge = True
if query == "" and len(args) > 0:
inp = file(args[0])
query = ""
for l in inp:
query += l
except:
usage()
if query == "":
usage()
main(server, query, sponge)
sparqlwrapper-1.8.5/setup.py 0000775 0000000 0000000 00000005326 13577650276 0016175 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
try:
from ez_setup import use_setuptools
use_setuptools()
except:
pass
from setuptools import setup
try:
import six
py3 = six.PY3
except:
py3 = sys.version_info[0] >= 3
# metadata
import re
_version_re = re.compile(r'__version__\s*=\s*"(.*)"')
_authors_re = re.compile(r'__authors__\s*=\s*"(.*)"')
_url_re = re.compile(r'__url__\s*=\s*"(.*)"')
for line in open('SPARQLWrapper/__init__.py'):
version_match = _version_re.match(line)
if version_match:
version = version_match.group(1)
authors_match = _authors_re.match(line)
if authors_match:
authors = authors_match.group(1)
url_match = _url_re.match(line)
if url_match:
url = url_match.group(1)
# requirements
with open('requirements.txt', 'r') as f:
_install_requires = [line.rstrip('\n') for line in f]
setup(
name = 'SPARQLWrapper',
version = version,
description = 'SPARQL Endpoint interface to Python',
long_description = 'This is a wrapper around a SPARQL service. It helps in creating the query URI and, possibly, convert the result into a more manageable format.',
license = 'W3C SOFTWARE NOTICE AND LICENSE',
author = authors,
url = url,
download_url = 'https://github.com/RDFLib/sparqlwrapper/releases',
platforms = ['any'],
packages = ['SPARQLWrapper'],
install_requires = _install_requires,
extras_require = {
'keepalive': ['keepalive>=0.5'],
},
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: W3C License',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Software Development :: Libraries :: Python Modules',
],
keywords = ['python', 'sparql', 'rdf', 'rdflib'],
use_2to3 = True,
use_2to3_fixers = ['custom_fixers'],
project_urls={
'Home': 'https://rdflib.github.io/sparqlwrapper/',
'Documentation': 'https://rdflib.github.io/sparqlwrapper/doc/',
'Source': 'https://github.com/RDFLib/sparqlwrapper',
'Tracker': 'https://github.com/RDFLib/sparqlwrapper/issues',
}
)
sparqlwrapper-1.8.5/test/ 0000775 0000000 0000000 00000000000 13577650276 0015431 5 ustar 00root root 0000000 0000000 sparqlwrapper-1.8.5/test/4store__v1_1_5__agroportal__test.py 0000664 0000000 0000000 00000167665 13577650276 0024250 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#!/usr/bin/python
import inspect
import os
import sys
import unittest
# prefer local copy to the one which is installed
# hack from http://stackoverflow.com/a/6098238/280539
_top_level_path = os.path.realpath(os.path.abspath(os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0],
".."
)))
if _top_level_path not in sys.path:
sys.path.insert(0, _top_level_path)
# end of hack
import warnings
warnings.simplefilter("always")
try:
from rdflib.graph import ConjunctiveGraph
except ImportError:
from rdflib import ConjunctiveGraph
from SPARQLWrapper import SPARQLWrapper, XML, RDFXML, RDF, N3, TURTLE, JSONLD, JSON, CSV, TSV, POST, GET
from SPARQLWrapper.Wrapper import _SPARQL_XML, _SPARQL_JSON, _XML, _RDF_XML, _RDF_N3, _RDF_TURTLE, _RDF_JSONLD, _CSV, _TSV
from SPARQLWrapper.SPARQLExceptions import QueryBadFormed
_SPARQL_SELECT_ASK_POSSIBLE = _SPARQL_XML + _SPARQL_JSON + _CSV + _TSV + _XML # only used in test
_SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE = _RDF_XML + _RDF_N3 + _XML + _RDF_JSONLD # only used in test. Same as Wrapper._RDF_POSSIBLE
try:
from urllib.error import HTTPError # Python 3
except ImportError:
from urllib2 import HTTPError # Python 2
try:
bytes # Python 2.6 and above
except NameError:
bytes = str
import logging
logging.basicConfig()
endpoint = "http://sparql.agroportal.lirmm.fr/sparql/" # 4store SPARQL server v1.1.5-122-g1788d29
prefixes = """
PREFIX rdf:
PREFIX rdfs:
PREFIX skos:
"""
selectQuery = """
SELECT DISTINCT ?s WHERE {
?s a ?o .
VALUES ?o {}
} LIMIT 100
"""
selectQueryCSV_TSV = """
SELECT DISTINCT ?s ?o WHERE {
?s a ?o .
VALUES ?o {}
} LIMIT 100
"""
askQuery = """
ASK { a ?type }
"""
constructQuery = """
CONSTRUCT {
_:v skos:prefLabel ?label .
_:v rdfs:comment "this is only a mock node to test library"
}
WHERE {
skos:prefLabel ?label .
}
"""
describeQuery = """
DESCRIBE
"""
queryBadFormed = """
PREFIX prop:
PREFIX res:
FROM
SELECT ?lat ?long
WHERE {
res:Budapest prop:latitude ?lat;
prop:longitude ?long.
}
"""
queryManyPrefixes = """
PREFIX conf:
PREFIX meta:
PREFIX rdf:
PREFIX rdfs:
PREFIX xsd:
PREFIX owl:
PREFIX dc:
PREFIX dcterms:
PREFIX foaf:
PREFIX skos:
PREFIX geo:
PREFIX dbpedia:
PREFIX o:
PREFIX p:
PREFIX yago:
PREFIX units:
PREFIX geonames:
PREFIX prv:
PREFIX prvTypes:
PREFIX foo:
SELECT ?label
WHERE {
rdfs:label ?label .
}
"""
queryDuplicatedPrefix = """
PREFIX rdf:
PREFIX rdf:
SELECT ?s ?p ?o WHERE {
?s ?p ?o .
} LIMIT 10
"""
queryWithCommaInCurie_1 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Victoria\\,\\_British\\_Columbia .
?article ?title
}
"""
queryWithCommaInCurie_2 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Category\:Victoria\,\_British\_Columbia .
?article ?title
}
"""
queryWithCommaInUri = """
SELECT ?article ?title WHERE {
?article ?relation .
?article ?title
}
"""
class SPARQLWrapperTests(unittest.TestCase):
def __generic(self, query, returnFormat, method, onlyConneg=False): # 4store uses URL parameters or conneg.
sparql = SPARQLWrapper(endpoint)
sparql.setQuery(prefixes + query)
sparql.setReturnFormat(returnFormat)
sparql.setMethod(method)
sparql.setOnlyConneg(onlyConneg)
try:
result = sparql.query()
except HTTPError:
# An ugly way to get the exception, but the only one that works
# both on Python 2.5 and Python 3.
e = sys.exc_info()[1]
if e.code == 400:
sys.stdout.write("400 Bad Request, probably query is not well formed")
elif e.code == 406:
sys.stdout.write("406 Not Acceptable, maybe query is not well formed")
else:
sys.stdout.write(str(e))
sys.stdout.write("\n")
return False
else:
return result
################################################################################
################################################################################
################
#### SELECT ####
################
def testSelectByGETinXML(self):
result = self.__generic(selectQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByGETinXML_Conneg(self):
result = self.__generic(selectQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML(self):
result = self.__generic(selectQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML_Conneg(self):
result = self.__generic(selectQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByGETinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinCSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinCSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("4store does not support receiving unexpected output values (check Wrapper code for TSV URL generation)")
def testSelectByGETinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinTSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinTSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinJSON(self):
result = self.__generic(selectQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByGETinJSON_Conneg(self):
result = self.__generic(selectQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON(self):
result = self.__generic(selectQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON_Conneg(self):
result = self.__generic(selectQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
@unittest.skip("4store does not support receiving unexpected output values (n3 is not a valid alias)")
def testSelectByGETinN3_Unexpected(self):
result = self.__generic(selectQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinN3_Unexpected_Conneg(self):
result = self.__generic(selectQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinN3_Unexpected(self):
result = self.__generic(selectQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinN3_Unexpected_Conneg(self):
result = self.__generic(selectQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
@unittest.skip("4store does not support receiving unexpected output values (json-ld is not a valid alias)")
def testSelectByGETinJSONLD_Unexpected(self):
result = self.__generic(selectQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinJSONLD_Unexpected_Conneg(self):
result = self.__generic(selectQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinJSONLD_Unexpected(self):
result = self.__generic(selectQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinJSONLD_Unexpected_Conneg(self):
result = self.__generic(selectQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinUnknow(self):
result = self.__generic(selectQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinUnknow_Conneg(self):
result = self.__generic(selectQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinUnknow(self):
result = self.__generic(selectQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinUnknow_Conneg(self):
result = self.__generic(selectQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
#############
#### ASK ####
#############
def testAskByGETinXML(self):
result = self.__generic(askQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByGETinXML_Conneg(self):
result = self.__generic(askQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML(self):
result = self.__generic(askQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML_Conneg(self):
result = self.__generic(askQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByGETinCSV(self):
result = self.__generic(askQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinCSV_Conneg(self):
result = self.__generic(askQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByPOSTinCSV(self):
result = self.__generic(askQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByPOSTinCSV_Conneg(self):
result = self.__generic(askQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV is supported for 4store, but it returns a text/plain instead of text/tab-separated-values")
def testAskByGETinTSV(self):
result = self.__generic(askQuery, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinTSV_Conneg(self):
result = self.__generic(askQuery, TSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByPOSTinTSV(self):
result = self.__generic(askQuery, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByPOSTinTSV_Conneg(self):
result = self.__generic(askQuery, TSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinJSON(self):
result = self.__generic(askQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByGETinJSON_Conneg(self):
result = self.__generic(askQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON(self):
result = self.__generic(askQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON_Conneg(self):
result = self.__generic(askQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
@unittest.skip("4store does not support receiving unexpected output values (n3 is not a valid alias)")
def testAskByGETinN3_Unexpected(self):
result = self.__generic(askQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinN3_Unexpected_Conneg(self):
result = self.__generic(askQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinN3_Unexpected(self):
result = self.__generic(askQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinN3_Unexpected_Conneg(self):
result = self.__generic(askQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
@unittest.skip("4store does not support receiving unexpected output values (json-ld is not a valid alias)")
def testAskByGETinJSONLD_Unexpected(self):
result = self.__generic(askQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinJSONLD_Unexpected_Conneg(self):
result = self.__generic(askQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinJSONLD_Unexpected(self):
result = self.__generic(askQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinJSONLD_Unexpected_Conneg(self):
result = self.__generic(askQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unknown return format for ASK queryType (XML is sent)
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinUnknow(self):
result = self.__generic(askQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinUnknow_Conneg(self):
result = self.__generic(askQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinUnknow(self):
result = self.__generic(askQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinUnknow_Conneg(self):
result = self.__generic(askQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
###################
#### CONSTRUCT ####
###################
def testConstructByGETinXML(self):
result = self.__generic(constructQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByGETinXML_Conneg(self):
result = self.__generic(constructQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML(self):
result = self.__generic(constructQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML_Conneg(self):
result = self.__generic(constructQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("4store does not support receiving unexpected output values (rdf+xml is not a valid alias)")
def testConstructByGETinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByGETinRDFXML_Conneg(self):
result = self.__generic(constructQuery, RDFXML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByPOSTinRDFXML_Conneg(self):
result = self.__generic(constructQuery, RDFXML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# turtle is not a valid alias ('text' is the one used)
@unittest.skip("4store does not support receiving unexpected output values (turtle is not a valid alias)")
def testConstructByGETinTURTLE(self):
result = self.__generic(constructQuery, TURTLE, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias ('text' is the one used)
# Working with Content Negotiation
def testConstructByGETinTURTLE_Conneg(self):
result = self.__generic(constructQuery, TURTLE, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias ('text' is the one used)
# But it returns text/turtle
def testConstructByPOSTinTURTLE(self):
result = self.__generic(constructQuery, TURTLE, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias ('text' is the one used)
# Working with Content Negotiation
def testConstructByPOSTinTURTLE_Conneg(self):
result = self.__generic(constructQuery, TURTLE, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("4store does not support receiving unexpected output values (n3 is not a valid alias)")
def testConstructByGETinN3(self):
result = self.__generic(constructQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# Returns text/turtle
def testConstructByGETinN3_Conneg(self):
result = self.__generic(constructQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testConstructByPOSTinN3(self):
result = self.__generic(constructQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# Returns text/turtle
def testConstructByPOSTinN3_Conneg(self):
result = self.__generic(constructQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("JSON-LD is not currently supported")
def testConstructByGETinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not currently supported")
def testConstructByGETinJSONLD_Conneg(self):
result = self.__generic(constructQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not currently supported")
def testConstructByPOSTinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not currently supported")
def testConstructByPOSTinJSONLD_Conneg(self):
result = self.__generic(constructQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
@unittest.skip("4store returns text/turtle instead of the expected default application/rdf+xml")
def testConstructByGETinCSV_Unexpected(self):
result = self.__generic(constructQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinCSV_Unexpected_Conneg(self):
result = self.__generic(constructQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinCSV_Unexpected(self):
result = self.__generic(constructQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinCSV_Unexpected_Conneg(self):
result = self.__generic(constructQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
@unittest.skip("4store returns text/turtle instead of the expected default application/rdf+xml")
def testConstructByGETinJSON_Unexpected(self):
result = self.__generic(constructQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByGETinJSON_Unexpected_Conneg(self):
result = self.__generic(constructQuery, JSON, GET , onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinJSON_Unexpected(self):
result = self.__generic(constructQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinJSON_Unexpected_Conneg(self):
result = self.__generic(constructQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinUnknow(self):
result = self.__generic(constructQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinUnknow_Conneg(self):
result = self.__generic(constructQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinUnknow(self):
result = self.__generic(constructQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinUnknow_Conneg(self):
result = self.__generic(constructQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
##################
#### DESCRIBE ####
##################
def testDescribeByGETinXML(self):
result = self.__generic(describeQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByGETinXML_Conneg(self):
result = self.__generic(describeQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML(self):
result = self.__generic(describeQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML_Conneg(self):
result = self.__generic(describeQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
@unittest.skip("4store does not support receiving unexpected output values (rdf+xml is not a valid alias)")
def testDescribeByGETinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByGETinRDFXML_Conneg(self):
result = self.__generic(describeQuery, RDFXML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByPOSTinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByPOSTinRDFXML_Conneg(self):
result = self.__generic(describeQuery, RDFXML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# turtle is not a valid alias ('text' is the one used)
@unittest.skip("4store does not support receiving unexpected output values (turtle is not a valid alias)")
def testDescribeByGETinTURTLE(self):
result = self.__generic(describeQuery, TURTLE, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias ('text' is the one used)
def testDescribeByGETinTURTLE_Conneg(self):
result = self.__generic(describeQuery, TURTLE, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias ('text' is the one used)
def testDescribeByPOSTinTURTLE(self):
result = self.__generic(describeQuery, TURTLE, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias ('text' is the one used)
def testDescribeByPOSTinTURTLE_Conneg(self):
result = self.__generic(describeQuery, TURTLE, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("4store does not support receiving unexpected output values (n3 is not a valid alias)")
def testDescribeByGETinN3(self):
result = self.__generic(describeQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# Returns text/turtle
def testDescribeByGETinN3_Conneg(self):
result = self.__generic(describeQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testDescribeByPOSTinN3(self):
result = self.__generic(describeQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# Returns text/turtle
def testDescribeByPOSTinN3_Conneg(self):
result = self.__generic(describeQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("JSON-LD is not currently supported")
def testDescribeByGETinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not currently supported")
def testDescribeByGETinJSONLD_Conneg(self):
result = self.__generic(describeQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not currently supported")
def testDescribeByPOSTinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not currently supported")
def testDescribeByPOSTinJSONLD_Conneg(self):
result = self.__generic(describeQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
@unittest.skip("4store returns text/csv instead of the expected default application/rdf+xml. AND the content of the response is a Turtle document. It MUST return an RDF graph [RDF-CONCEPTS] serialized, for example, in the RDF/XML syntax [RDF-XML], or an equivalent RDF graph serialization, for SPARQL Query forms DESCRIBE and CONSTRUCT). See http://www.w3.org/TR/sparql11-protocol/#query-success")
def testDescribeByGETinCSV_Unexpected(self):
result = self.__generic(describeQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinCSV_Unexpected_Conneg(self):
result = self.__generic(describeQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinCSV_Unexpected(self):
result = self.__generic(describeQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinCSV_Unexpected_Conneg(self):
result = self.__generic(describeQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
@unittest.skip("4store returns application/sparql-results+json instead of the expected default application/rdf+xml. It MUST return an RDF graph [RDF-CONCEPTS] serialized, for example, in the RDF/XML syntax [RDF-XML], or an equivalent RDF graph serialization, for SPARQL Query forms DESCRIBE and CONSTRUCT). See http://www.w3.org/TR/sparql11-protocol/#query-success")
def testDescribeByGETinJSON_Unexpected(self):
result = self.__generic(describeQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinJSON_Unexpected_Conneg(self):
result = self.__generic(describeQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinJSON_Unexpected(self):
result = self.__generic(describeQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinJSON_Unexpected_Conneg(self):
result = self.__generic(describeQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinUnknow(self):
result = self.__generic(describeQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinUnknow_Conneg(self):
result = self.__generic(describeQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinUnknow(self):
result = self.__generic(describeQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinUnknow_Conneg(self):
result = self.__generic(describeQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
def testQueryBadFormed(self):
self.assertRaises(QueryBadFormed, self.__generic, queryBadFormed, XML, GET)
def testQueryManyPrefixes(self):
result = self.__generic(queryManyPrefixes, XML, GET)
def testQueryDuplicatedPrefix(self):
result = self.__generic(queryDuplicatedPrefix, XML, GET)
def testKeepAlive(self):
sparql = SPARQLWrapper(endpoint)
sparql.setQuery('SELECT * WHERE {?s ?p ?o} LIMIT 10')
sparql.setReturnFormat(JSON)
sparql.setMethod(GET)
sparql.setUseKeepAlive()
sparql.query()
sparql.query()
@unittest.skip('Store 4. parser error: Failed to decode SPARQL ID "dbpedia:Victoria\". See #94')
def testQueryWithComma_1(self):
result = self.__generic(queryWithCommaInCurie_1, XML, GET)
@unittest.skip('Store 4. parser error: Failed to decode SPARQL ID "dbpedia:Category\". See #94')
def testQueryWithComma_2(self):
result = self.__generic(queryWithCommaInCurie_2, XML, POST)
def testQueryWithComma_3(self):
result = self.__generic(queryWithCommaInUri, XML, GET)
if __name__ == "__main__":
unittest.main()
sparqlwrapper-1.8.5/test/agrovoc-allegrograph_on_hold.py 0000664 0000000 0000000 00000072341 13577650276 0023621 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#!/usr/bin/python
import inspect
import os
import sys
import unittest
# prefer local copy to the one which is installed
# hack from http://stackoverflow.com/a/6098238/280539
_top_level_path = os.path.realpath(os.path.abspath(os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0],
".."
)))
if _top_level_path not in sys.path:
sys.path.insert(0, _top_level_path)
# end of hack
import warnings
warnings.simplefilter("always")
try:
from rdflib.graph import ConjunctiveGraph
except ImportError:
from rdflib import ConjunctiveGraph
from SPARQLWrapper import SPARQLWrapper, XML, RDFXML, RDF, N3, TURTLE, JSONLD, JSON, CSV, TSV, POST, GET
from SPARQLWrapper.Wrapper import _SPARQL_XML, _SPARQL_JSON, _XML, _RDF_XML, _RDF_N3, _RDF_TURTLE, _RDF_JSONLD, _CSV, _TSV
from SPARQLWrapper.SPARQLExceptions import QueryBadFormed
_SPARQL_SELECT_ASK_POSSIBLE = _SPARQL_XML + _SPARQL_JSON + _CSV + _TSV + _XML # only used in test
_SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE = _RDF_XML + _RDF_N3 + _XML + _RDF_JSONLD # only used in test. Same as Wrapper._RDF_POSSIBLE
try:
from urllib.error import HTTPError # Python 3
except ImportError:
from urllib2 import HTTPError # Python 2
try:
bytes # Python 2.6 and above
except NameError:
bytes = str
import logging
logging.basicConfig()
endpoint = "http://202.45.139.84:10035/catalogs/fao/repositories/agrovoc"
prefixes = """
PREFIX rdf:
PREFIX rdfs:
PREFIX skos:
"""
selectQuery = """
SELECT ?label
WHERE {
skos:prefLabel ?label .
}
"""
selectQueryCSV_TSV = """
SELECT ?label ?created
WHERE {
skos:prefLabel ?label ;
?created
}
"""
askQuery = """
ASK { a ?type }
"""
constructQuery = """
CONSTRUCT {
_:v skos:prefLabel ?label .
_:v rdfs:comment "this is only a mock node to test library"
}
WHERE {
skos:prefLabel ?label .
}
"""
describeQuery = """
DESCRIBE
"""
queryBadFormed = """
PREFIX prop:
PREFIX res:
FROM
SELECT ?lat ?long
WHERE {
res:Budapest prop:latitude ?lat;
prop:longitude ?long.
}
"""
queryManyPrefixes = """
PREFIX conf:
PREFIX meta:
PREFIX rdf:
PREFIX rdfs:
PREFIX xsd:
PREFIX owl:
PREFIX dc:
PREFIX dcterms:
PREFIX foaf:
PREFIX skos:
PREFIX geo:
PREFIX dbpedia:
PREFIX o:
PREFIX p:
PREFIX yago:
PREFIX units:
PREFIX geonames:
PREFIX prv:
PREFIX prvTypes:
PREFIX foo:
SELECT ?label
WHERE {
rdfs:label ?label .
}
"""
queryDuplicatedPrefix = """
PREFIX rdf:
PREFIX rdf:
SELECT ?s ?p ?o WHERE {
?s ?p ?o .
} LIMIT 10
"""
queryWithCommaInCurie_1 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Victoria\\,\\_British\\_Columbia .
?article ?title
}
"""
queryWithCommaInCurie_2 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Category\:Victoria\,\_British\_Columbia .
?article ?title
}
"""
queryWithCommaInUri = """
SELECT ?article ?title WHERE {
?article ?relation .
?article ?title
}
"""
class SPARQLWrapperTests(unittest.TestCase):
def __generic(self, query, returnFormat, method, onlyConneg=True): # Allegrograph uses only content negotiation (no URL parameters).
sparql = SPARQLWrapper(endpoint)
sparql.setQuery(prefixes + query)
sparql.setReturnFormat(returnFormat)
sparql.setMethod(method)
sparql.setOnlyConneg(onlyConneg)
try:
result = sparql.query()
except HTTPError:
# An ugly way to get the exception, but the only one that works
# both on Python 2.5 and Python 3.
e = sys.exc_info()[1]
if e.code == 400:
sys.stdout.write("400 Bad Request, probably query is not well formed")
elif e.code == 406:
sys.stdout.write("406 Not Acceptable, maybe query is not well formed")
else:
sys.stdout.write(str(e))
sys.stdout.write("\n")
return False
else:
return result
################################################################################
################################################################################
################
#### SELECT ####
################
def testSelectByGETinXML(self):
result = self.__generic(selectQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML(self):
result = self.__generic(selectQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByGETinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinJSON(self):
result = self.__generic(selectQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON(self):
result = self.__generic(selectQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# asking for an unexpected return format for SELECT queryType
def testSelectByGETinN3(self):
result = self.__generic(selectQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unexpected return format for SELECT queryType
def testSelectByPOSTinN3(self):
result = self.__generic(selectQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unexpected return format for SELECT queryType
def testSelectByGETinJSONLD(self):
result = self.__generic(selectQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unexpected return format for SELECT queryType
def testSelectByPOSTinJSONLD(self):
result = self.__generic(selectQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByGETinUnknow(self):
result = self.__generic(selectQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByPOSTinUnknow(self):
result = self.__generic(selectQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
#############
#### ASK ####
#############
def testAskByGETinXML(self):
result = self.__generic(askQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML(self):
result = self.__generic(askQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
@unittest.skip("CSV (text/csv) is not supported currently for AllegroGraph for ASK query type")
def testAskByGETinCSV(self):
result = self.__generic(askQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
@unittest.skip("CSV (text/csv) is not supported currently for AllegroGraph for ASK query type")
def testAskByPOSTinCSV(self):
result = self.__generic(askQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
@unittest.skip("TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type")
def testAskByGETinTSV(self):
result = self.__generic(askQuery, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
@unittest.skip("TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type")
def testAskByPOSTinTSV(self):
result = self.__generic(askQuery, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
def testAskByGETinJSON(self):
result = self.__generic(askQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON(self):
result = self.__generic(askQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# asking for an unexpected return format for ASK queryType
def testAskByGETinN3(self):
result = self.__generic(askQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unexpected return format for ASK queryType
def testAskByPOSTinN3(self):
result = self.__generic(askQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unexpected return format for ASK queryType
def testAskByGETinJSONLD(self):
result = self.__generic(askQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unexpected return format for ASK queryType
def testAskByPOSTinJSONLD(self):
result = self.__generic(askQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unknown return format for ASK queryType (XML is sent)
def testAskByGETinUnknow(self):
result = self.__generic(askQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# asking for an unknown return format for ASK queryType (XML is sent)
def testAskByPOSTinUnknow(self):
result = self.__generic(askQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
results.toxml()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
###################
#### CONSTRUCT ####
###################
def testConstructByGETinXML(self):
result = self.__generic(constructQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML(self):
result = self.__generic(constructQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByGETinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByGETinN3(self):
result = self.__generic(constructQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testConstructByPOSTinN3(self):
result = self.__generic(constructQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# JSON-LD is not supported currently for AllegroGraph
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testConstructByGETinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# JSON-LD is not supported currently for AllegroGraph
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testConstructByPOSTinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unexpected return format for CONSTRUCT queryType
def testConstructByGETinJSON(self):
result = self.__generic(constructQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unexpected return format for CONSTRUCT queryType
def testConstructByPOSTinJSON(self):
result = self.__generic(constructQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unexpected return format for CONSTRUCT queryType. For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinCSV(self):
result = self.__generic(constructQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" %(ct)
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unexpected return format for CONSTRUCT queryType. For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinCSV(self):
result = self.__generic(constructQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" %(ct)
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByGETinUnknow(self):
result = self.__generic(constructQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByPOSTinUnknow(self):
result = self.__generic(constructQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
##################
#### DESCRIBE ####
##################
def testDescribeByGETinXML(self):
result = self.__generic(describeQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML(self):
result = self.__generic(describeQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByGETinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByGETinN3(self):
result = self.__generic(describeQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testDescribeByPOSTinN3(self):
result = self.__generic(describeQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# JSON-LD is not supported currently for AllegroGraph
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testDescribeByGETinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# JSON-LD is not supported currently for AllegroGraph
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testDescribeByPOSTinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unexpected return format for DESCRIBE queryType
def testDescribeByGETinJSON(self):
result = self.__generic(describeQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unexpected return format for DESCRIBE queryType
def testDescribeByPOSTinJSON(self):
result = self.__generic(describeQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unexpected return format for DESCRIBE queryType. For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinCSV(self):
result = self.__generic(describeQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" %(ct)
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unexpected return format for DESCRIBE queryType. For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinCSV(self):
result = self.__generic(describeQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], "returned Content-Type='%s'. Expected fail due to Virtuoso configuration" %(ct)
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByGETinUnknow(self):
result = self.__generic(describeQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByPOSTinUnknow(self):
result = self.__generic(describeQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
def testQueryBadFormed(self):
self.assertRaises(QueryBadFormed, self.__generic, queryBadFormed, XML, GET)
def testQueryManyPrefixes(self):
result = self.__generic(queryManyPrefixes, XML, GET)
def testQueryDuplicatedPrefix(self):
result = self.__generic(queryDuplicatedPrefix, XML, GET)
def testKeepAlive(self):
sparql = SPARQLWrapper(endpoint)
sparql.setQuery('SELECT * WHERE {?s ?p ?o} LIMIT 10')
sparql.setReturnFormat(JSON)
sparql.setMethod(GET)
sparql.setUseKeepAlive()
sparql.query()
sparql.query()
@unittest.skip("Allegrograph returns Value \"\\\" not recognized Error. See #94")
def testQueryWithComma_1(self):
result = self.__generic(queryWithCommaInCurie_1, XML, GET)
@unittest.skip("Allegrograph returns Value \"\\\" not recognized Error. See #94")
def testQueryWithComma_2(self):
result = self.__generic(queryWithCommaInCurie_2, XML, POST)
def testQueryWithComma_3(self):
result = self.__generic(queryWithCommaInUri, XML, GET)
if __name__ == "__main__":
unittest.main()
sparqlwrapper-1.8.5/test/allegrograph__v4_14_1__mmi__test.py 0000664 0000000 0000000 00000163543 13577650276 0024161 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#!/usr/bin/python
import inspect
import os
import sys
import unittest
# prefer local copy to the one which is installed
# hack from http://stackoverflow.com/a/6098238/280539
_top_level_path = os.path.realpath(os.path.abspath(os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0],
".."
)))
if _top_level_path not in sys.path:
sys.path.insert(0, _top_level_path)
# end of hack
import warnings
warnings.simplefilter("always")
try:
from rdflib.graph import ConjunctiveGraph
except ImportError:
from rdflib import ConjunctiveGraph
from SPARQLWrapper import SPARQLWrapper, XML, RDFXML, RDF, N3, TURTLE, JSONLD, JSON, CSV, TSV, POST, GET
from SPARQLWrapper.Wrapper import _SPARQL_XML, _SPARQL_JSON, _XML, _RDF_XML, _RDF_N3, _RDF_TURTLE, _RDF_JSONLD, _CSV, _TSV
from SPARQLWrapper.SPARQLExceptions import QueryBadFormed
_SPARQL_SELECT_ASK_POSSIBLE = _SPARQL_XML + _SPARQL_JSON + _CSV + _TSV + _XML # only used in test
_SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE = _RDF_XML + _RDF_N3 + _XML + _RDF_JSONLD # only used in test. Same as Wrapper._RDF_POSSIBLE
try:
from urllib.error import HTTPError # Python 3
except ImportError:
from urllib2 import HTTPError # Python 2
try:
bytes # Python 2.6 and above
except NameError:
bytes = str
import logging
logging.basicConfig()
endpoint = "https://mmisw.org/sparql" # 4.14.1 http://mmisw.org:10035/doc/release-notes.html # AllegroServe/1.3.28
prefixes = """
PREFIX rdf:
PREFIX rdfs:
PREFIX skos:
PREFIX ioosCat:
PREFIX ioosPlat:
"""
selectQuery = """
SELECT ?p
WHERE { ?p a ioosCat:Category }
ORDER BY ?p
"""
selectQueryCSV_TSV = """
SELECT DISTINCT ?cat ?platform ?definition
WHERE {
?platform a ioosPlat:Platform .
?platform ioosPlat:Definition ?definition .
?cat skos:narrowMatch ?platform .
}
ORDER BY ?cat ?platform
"""
askQuery = """
ASK { a ?type }
"""
constructQuery = """
CONSTRUCT {
_:v skos:prefLabel ?label .
_:v rdfs:comment "this is only a mock node to test library"
}
WHERE {
rdfs:label ?label .
}
"""
describeQuery = """
DESCRIBE
"""
queryBadFormed = """
PREFIX prop:
PREFIX res:
FROM
SELECT ?lat ?long
WHERE {
res:Budapest prop:latitude ?lat;
prop:longitude ?long.
}
"""
queryManyPrefixes = """
PREFIX conf:
PREFIX meta:
PREFIX xsd:
PREFIX owl:
PREFIX dc:
PREFIX dcterms:
PREFIX foaf:
PREFIX geo:
PREFIX dbpedia:
PREFIX o:
PREFIX p:
PREFIX yago:
PREFIX units:
PREFIX geonames:
PREFIX prv:
PREFIX prvTypes:
PREFIX foo:
SELECT * WHERE {
?subject ?predicate ?object .
} LIMIT 10
"""
queryDuplicatedPrefix = """
PREFIX rdf:
PREFIX rdf:
SELECT ?s ?p ?o WHERE {
?s ?p ?o .
} LIMIT 10
"""
queryWithCommaInCurie_1 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Victoria\\,\\_British\\_Columbia .
?article ?title
}
"""
queryWithCommaInCurie_2 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Category\:Victoria\,\_British\_Columbia .
?article ?title
}
"""
queryWithCommaInUri = """
SELECT ?article ?title WHERE {
?article ?relation .
?article ?title
}
"""
class SPARQLWrapperTests(unittest.TestCase):
def __generic(self, query, returnFormat, method, onlyConneg=False): # AllegroGraph uses URL parameters or content negotiation.
sparql = SPARQLWrapper(endpoint)
sparql.setQuery(prefixes + query)
sparql.setReturnFormat(returnFormat)
sparql.setMethod(method)
sparql.setOnlyConneg(onlyConneg)
try:
result = sparql.query()
except HTTPError:
# An ugly way to get the exception, but the only one that works
# both on Python 2.5 and Python 3.
e = sys.exc_info()[1]
if e.code == 400:
sys.stdout.write("400 Bad Request, probably query is not well formed")
elif e.code == 406:
sys.stdout.write("406 Not Acceptable, maybe query is not well formed")
else:
sys.stdout.write(str(e))
sys.stdout.write("\n")
return False
else:
return result
################################################################################
################################################################################
################
#### SELECT ####
################
def testSelectByGETinXML(self):
result = self.__generic(selectQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByGETinXML_Conneg(self):
result = self.__generic(selectQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML(self):
result = self.__generic(selectQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML_Conneg(self):
result = self.__generic(selectQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByGETinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinCSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinCSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinTSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinTSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinJSON(self):
result = self.__generic(selectQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByGETinJSON_Conneg(self):
result = self.__generic(selectQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON(self):
result = self.__generic(selectQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON_Conneg(self):
result = self.__generic(selectQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinN3_Unexpected(self):
result = self.__generic(selectQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinN3_Unexpected_Conneg(self):
result = self.__generic(selectQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinN3_Unexpected(self):
result = self.__generic(selectQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinN3_Unexpected_Conneg(self):
result = self.__generic(selectQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinJSONLD_Unexpected(self):
result = self.__generic(selectQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinJSONLD_Unexpected_Conneg(self):
result = self.__generic(selectQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinJSONLD_Unexpected(self):
result = self.__generic(selectQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinJSONLD_Unexpected_Conneg(self):
result = self.__generic(selectQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByGETinUnknow(self):
result = self.__generic(selectQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByGETinUnknow_Conneg(self):
result = self.__generic(selectQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByPOSTinUnknow(self):
result = self.__generic(selectQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByPOSTinUnknow_Conneg(self):
result = self.__generic(selectQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
#############
#### ASK ####
#############
def testAskByGETinXML(self):
result = self.__generic(askQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByGETinXML_Conneg(self):
result = self.__generic(askQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML(self):
result = self.__generic(askQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML_Conneg(self):
result = self.__generic(askQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
@unittest.skip("CSV (text/csv) is not supported currently for AllegroGraph for ASK query type")
def testAskByGETinCSV(self):
result = self.__generic(askQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("CSV (text/csv) is not supported currently for AllegroGraph for ASK query type")
def testAskByGETinCSV_Conneg(self):
result = self.__generic(askQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("CSV (text/csv) is not supported currently for AllegroGraph for ASK query type")
def testAskByPOSTinCSV(self):
result = self.__generic(askQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("CSV (text/csv) is not supported currently for AllegroGraph for ASK query type")
def testAskByPOSTinCSV_Conneg(self):
result = self.__generic(askQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type")
def testAskByGETinTSV(self):
result = self.__generic(askQuery, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type")
def testAskByGETinTSV_Conneg(self):
result = self.__generic(askQuery, TSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type")
def testAskByPOSTinTSV(self):
result = self.__generic(askQuery, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV (text/tab-separated-values) is not supported currently for AllegroGraph for ASK query type")
def testAskByPOSTinTSV_Conneg(self):
result = self.__generic(askQuery, TSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinJSON(self):
result = self.__generic(askQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByGETinJSON_Conneg(self):
result = self.__generic(askQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON(self):
result = self.__generic(askQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON_Conneg(self):
result = self.__generic(askQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinN3_Unexpected(self):
result = self.__generic(askQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinN3_Unexpected_Conneg(self):
result = self.__generic(askQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinN3_Unexpected(self):
result = self.__generic(askQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinN3_Unexpected_Conneg(self):
result = self.__generic(askQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinJSONLD_Unexpected(self):
result = self.__generic(askQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinJSONLD_Unexpected_Conneg(self):
result = self.__generic(askQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinJSONLD_Unexpected(self):
result = self.__generic(askQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinJSONLD_Unexpected_Conneg(self):
result = self.__generic(askQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByGETinUnknow(self):
result = self.__generic(askQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByGETinUnknow_Conneg(self):
result = self.__generic(askQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByPOSTinUnknow(self):
result = self.__generic(askQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByPOSTinUnknow_Conneg(self):
result = self.__generic(askQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
###################
#### CONSTRUCT ####
###################
def testConstructByGETinXML(self):
result = self.__generic(constructQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByGETinXML_Conneg(self):
result = self.__generic(constructQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML(self):
result = self.__generic(constructQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML_Conneg(self):
result = self.__generic(constructQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByGETinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByGETinRDFXML_Conneg(self):
result = self.__generic(constructQuery, RDFXML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByPOSTinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByPOSTinRDFXML_Conneg(self):
result = self.__generic(constructQuery, RDFXML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("Turtle is not supported currently for AllegroGraph")
def testConstructByGETinTURTLE(self):
result = self.__generic(constructQuery, TURTLE, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Turtle is not supported currently for AllegroGraph")
def testConstructByGETinTURTLE_Conneg(self):
result = self.__generic(constructQuery, TURTLE, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Turtle is not supported currently for AllegroGraph")
def testConstructByPOSTinTURTLE(self):
result = self.__generic(constructQuery, TURTLE, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Turtle is not supported currently for AllegroGraph")
def testConstructByPOSTinTURTLE_Conneg(self):
result = self.__generic(constructQuery, TURTLE, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testConstructByGETinN3(self):
result = self.__generic(constructQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testConstructByGETinN3_Conneg(self):
result = self.__generic(constructQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testConstructByPOSTinN3(self):
result = self.__generic(constructQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testConstructByPOSTinN3_Conneg(self):
result = self.__generic(constructQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testConstructByGETinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testConstructByGETinJSONLD_Conneg(self):
result = self.__generic(constructQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testConstructByPOSTinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testConstructByPOSTinJSONLD_Conneg(self):
result = self.__generic(constructQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinCSV_Unexpected(self):
result = self.__generic(constructQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinCSV_Unexpected_Conneg(self):
result = self.__generic(constructQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinCSV_Unexpected(self):
result = self.__generic(constructQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinCSV_Unexpected_Conneg(self):
result = self.__generic(constructQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinJSON_Unexpected(self):
result = self.__generic(constructQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinJSON_Unexpected_Conneg(self):
result = self.__generic(constructQuery, JSON, GET , onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinJSON_Unexpected(self):
result = self.__generic(constructQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinJSON_Unexpected_Conneg(self):
result = self.__generic(constructQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByGETinUnknow(self):
result = self.__generic(constructQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByGETinUnknow_Conneg(self):
result = self.__generic(constructQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByPOSTinUnknow(self):
result = self.__generic(constructQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByPOSTinUnknow_Conneg(self):
result = self.__generic(constructQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
##################
#### DESCRIBE ####
##################
def testDescribeByGETinXML(self):
result = self.__generic(describeQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByGETinXML_Conneg(self):
result = self.__generic(describeQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML(self):
result = self.__generic(describeQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML_Conneg(self):
result = self.__generic(describeQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByGETinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByGETinRDFXML_Conneg(self):
result = self.__generic(describeQuery, RDFXML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByPOSTinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByPOSTinRDFXML_Conneg(self):
result = self.__generic(describeQuery, RDFXML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("Turtle is not supported currently for AllegroGraph")
def testDescribeByGETinTURTLE(self):
result = self.__generic(describeQuery, TURTLE, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Turtle is not supported currently for AllegroGraph")
def testDescribeByGETinTURTLE_Conneg(self):
result = self.__generic(describeQuery, TURTLE, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Turtle is not supported currently for AllegroGraph")
def testDescribeByPOSTinTURTLE(self):
result = self.__generic(describeQuery, TURTLE, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Turtle is not supported currently for AllegroGraph")
def testDescribeByPOSTinTURTLE_Conneg(self):
result = self.__generic(describeQuery, TURTLE, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testDescribeByGETinN3(self):
result = self.__generic(describeQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testDescribeByGETinN3_Conneg(self):
result = self.__generic(describeQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testDescribeByPOSTinN3(self):
result = self.__generic(describeQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testDescribeByPOSTinN3_Conneg(self):
result = self.__generic(describeQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testDescribeByGETinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testDescribeByGETinJSONLD_Conneg(self):
result = self.__generic(describeQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testDescribeByPOSTinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("JSON-LD is not supported currently for AllegroGraph")
def testDescribeByPOSTinJSONLD_Conneg(self):
result = self.__generic(describeQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinCSV_Unexpected(self):
result = self.__generic(describeQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
# Returned application/rdf+xml
def testDescribeByGETinCSV_Unexpected_Conneg(self):
result = self.__generic(describeQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinCSV_Unexpected(self):
result = self.__generic(describeQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinCSV_Unexpected_Conneg(self):
result = self.__generic(describeQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinJSON_Unexpected(self):
result = self.__generic(describeQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinJSON_Unexpected_Conneg(self):
result = self.__generic(describeQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinJSON_Unexpected(self):
result = self.__generic(describeQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinJSON_Unexpected_Conneg(self):
result = self.__generic(describeQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByGETinUnknow(self):
result = self.__generic(describeQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByGETinUnknow_Conneg(self):
result = self.__generic(describeQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByPOSTinUnknow(self):
result = self.__generic(describeQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByPOSTinUnknow_Conneg(self):
result = self.__generic(describeQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
def testQueryBadFormed(self):
self.assertRaises(QueryBadFormed, self.__generic, queryBadFormed, XML, GET)
def testQueryManyPrefixes(self):
result = self.__generic(queryManyPrefixes, XML, GET)
def testQueryDuplicatedPrefix(self):
result = self.__generic(queryDuplicatedPrefix, XML, GET)
def testKeepAlive(self):
sparql = SPARQLWrapper(endpoint)
sparql.setQuery('SELECT * WHERE {?s ?p ?o} LIMIT 10')
sparql.setReturnFormat(JSON)
sparql.setMethod(GET)
sparql.setUseKeepAlive()
sparql.query()
sparql.query()
@unittest.skip("Allegrograph returns Value \"\\\" not recognized Error. See #94")
def testQueryWithComma_1(self):
result = self.__generic(queryWithCommaInCurie_1, XML, GET)
@unittest.skip("Allegrograph returns Value \"\\\" not recognized Error. See #94")
def testQueryWithComma_2(self):
result = self.__generic(queryWithCommaInCurie_2, XML, POST)
def testQueryWithComma_3(self):
result = self.__generic(queryWithCommaInUri, XML, GET)
if __name__ == "__main__":
unittest.main()
sparqlwrapper-1.8.5/test/blazegraph__wikidata__test.py 0000664 0000000 0000000 00000171364 13577650276 0023350 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#!/usr/bin/python
import time
import inspect
import os
import sys
import unittest
# prefer local copy to the one which is installed
# hack from http://stackoverflow.com/a/6098238/280539
_top_level_path = os.path.realpath(os.path.abspath(os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0],
".."
)))
if _top_level_path not in sys.path:
sys.path.insert(0, _top_level_path)
# end of hack
import warnings
warnings.simplefilter("always")
try:
from rdflib.graph import ConjunctiveGraph
except ImportError:
from rdflib import ConjunctiveGraph
from SPARQLWrapper import SPARQLWrapper, XML, RDFXML, RDF, N3, TURTLE, JSONLD, JSON, CSV, TSV, POST, GET
from SPARQLWrapper.Wrapper import _SPARQL_XML, _SPARQL_JSON, _XML, _RDF_XML, _RDF_N3, _RDF_TURTLE, _RDF_JSONLD, _CSV, _TSV
from SPARQLWrapper.SPARQLExceptions import QueryBadFormed
_SPARQL_SELECT_ASK_POSSIBLE = _SPARQL_XML + _SPARQL_JSON + _CSV + _TSV + _XML # only used in test
_SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE = _RDF_XML + _RDF_N3 + _XML + _RDF_JSONLD # only used in test. Same as Wrapper._RDF_POSSIBLE
try:
from urllib.error import HTTPError # Python 3
except ImportError:
from urllib2 import HTTPError # Python 2
try:
bytes # Python 2.6 and above
except NameError:
bytes = str
import logging
logging.basicConfig()
endpoint = "https://query.wikidata.org/sparql"
prefixes = """
PREFIX rdf:
PREFIX rdfs:
PREFIX skos:
PREFIX entity:
"""
selectQuery = """
SELECT ?predicate ?object WHERE {
entity:Q3934 ?predicate ?object .
} LIMIT 10
"""
selectQueryCSV_TSV = """
SELECT ?predicate ?object WHERE {
entity:Q3934 ?predicate ?object .
} LIMIT 10
"""
askQuery = """
ASK { rdfs:label "Asturias"@es }
"""
constructQuery = """
CONSTRUCT {
_:v skos:prefLabel ?label .
_:v rdfs:comment "this is only a mock node to test library"
}
WHERE {
rdfs:label ?label .
FILTER langMatches( lang(?label), "es" )
}
"""
describeQuery = """
DESCRIBE
"""
queryBadFormed = """
PREFIX prop:
PREFIX res:
FROM
SELECT ?lat ?long
WHERE {
res:Budapest prop:latitude ?lat;
prop:longitude ?long.
}
"""
queryDuplicatedPrefix = """
PREFIX rdf:
PREFIX rdf:
PREFIX rdfs:
PREFIX skos:
PREFIX entity:
SELECT ?predicate ?object WHERE {
entity:Q3934 ?predicate ?object .
} LIMIT 10
"""
queryManyPrefixes = """
PREFIX conf:
PREFIX meta:
PREFIX xsd:
PREFIX owl:
PREFIX dc:
PREFIX dcterms:
PREFIX foaf:
PREFIX geo:
PREFIX dbpedia:
PREFIX o:
PREFIX p:
PREFIX yago:
PREFIX units:
PREFIX geonames:
PREFIX prv:
PREFIX prvTypes:
PREFIX foo:
SELECT ?predicate ?object WHERE {
entity:Q3934 ?predicate ?object .
} LIMIT 10
"""
queryDuplicatedPrefix = """
PREFIX rdf:
PREFIX rdf:
SELECT ?s ?p ?o WHERE {
?s ?p ?o .
} LIMIT 10
"""
queryWithCommaInCurie_1 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Victoria\\,\\_British\\_Columbia .
?article ?title
}
"""
queryWithCommaInCurie_2 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Category\:Victoria\,\_British\_Columbia .
?article ?title
}
"""
queryWithCommaInUri = """
SELECT ?article ?title WHERE {
?article ?relation .
?article ?title
}
"""
class SPARQLWrapperTests(unittest.TestCase):
def __generic(self, query, returnFormat, method, onlyConneg=False): # Blazegraph uses URL parameters or content negotiation.
sparql = SPARQLWrapper(endpoint)
sparql.setQuery(prefixes + query)
sparql.setReturnFormat(returnFormat)
sparql.setMethod(method)
sparql.setOnlyConneg(onlyConneg)
try:
time.sleep(2.5) # sleeps for 2.5 seconds, in order to avoid disruptions in the server
result = sparql.query()
except HTTPError:
# An ugly way to get the exception, but the only one that works
# both on Python 2.5 and Python 3.
e = sys.exc_info()[1]
if e.code == 400:
sys.stdout.write("400 Bad Request, probably query is not well formed")
elif e.code == 406:
sys.stdout.write("406 Not Acceptable, maybe query is not well formed")
else:
sys.stdout.write(str(e))
sys.stdout.write("\n")
return False
else:
return result
################################################################################
################################################################################
################
#### SELECT ####
################
def testSelectByGETinXML(self):
result = self.__generic(selectQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByGETinXML_Conneg(self):
result = self.__generic(selectQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML(self):
result = self.__generic(selectQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML_Conneg(self):
result = self.__generic(selectQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. csv is not a valid alias. Use content negotiation instead")
def testSelectByGETinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinCSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. csv is not a valid alias. Use content negotiation instead")
def testSelectByPOSTinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinCSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. tsv is not a valid alias. Use content negotiation instead")
def testSelectByGETinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinTSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. tsv is not a valid alias. Use content negotiation instead")
def testSelectByPOSTinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinTSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinJSON(self):
result = self.__generic(selectQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByGETinJSON_Conneg(self):
result = self.__generic(selectQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON(self):
result = self.__generic(selectQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON_Conneg(self):
result = self.__generic(selectQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinN3_Unexpected(self):
result = self.__generic(selectQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinN3_Unexpected_Conneg(self):
result = self.__generic(selectQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinN3_Unexpected(self):
result = self.__generic(selectQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinN3_Unexpected_Conneg(self):
result = self.__generic(selectQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinJSONLD_Unexpected(self):
result = self.__generic(selectQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByGETinJSONLD_Unexpected_Conneg(self):
result = self.__generic(selectQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinJSONLD_Unexpected(self):
result = self.__generic(selectQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testSelectByPOSTinJSONLD_Unexpected_Conneg(self):
result = self.__generic(selectQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByGETinUnknow(self):
result = self.__generic(selectQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByGETinUnknow_Conneg(self):
result = self.__generic(selectQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByPOSTinUnknow(self):
result = self.__generic(selectQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByPOSTinUnknow_Conneg(self):
result = self.__generic(selectQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
#############
#### ASK ####
#############
def testAskByGETinXML(self):
result = self.__generic(askQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByGETinXML_Conneg(self):
result = self.__generic(askQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML(self):
result = self.__generic(askQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML_Conneg(self):
result = self.__generic(askQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
@unittest.skip("CSV is not supported for ASK queries in Blazegraph")
def testAskByGETinCSV(self):
result = self.__generic(askQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("CSV is not supported for ASK queries in Blazegraph")
def testAskByGETinCSV_Conneg(self):
result = self.__generic(askQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("CSV is not supported for ASK queries in Blazegraph")
def testAskByPOSTinCSV(self):
result = self.__generic(askQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("CSV is not supported for ASK queries in Blazegraph")
def testAskByPOSTinCSV_Conneg(self):
result = self.__generic(askQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV is not supported for ASK queries in Blazegraph")
def testAskByGETinTSV(self):
result = self.__generic(askQuery, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV is not supported for ASK queries in Blazegraph")
def testAskByGETinTSV_Conneg(self):
result = self.__generic(askQuery, TSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV is not supported for ASK queries in Blazegraph")
def testAskByPOSTinTSV(self):
result = self.__generic(askQuery, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("TSV is not supported for ASK queries in Blazegraph")
def testAskByPOSTinTSV_Conneg(self):
result = self.__generic(askQuery, TSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinJSON(self):
result = self.__generic(askQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByGETinJSON_Conneg(self):
result = self.__generic(askQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON(self):
result = self.__generic(askQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON_Conneg(self):
result = self.__generic(askQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinN3_Unexpected(self):
result = self.__generic(askQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinN3_Unexpected_Conneg(self):
result = self.__generic(askQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinN3_Unexpected(self):
result = self.__generic(askQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinN3_Unexpected_Conneg(self):
result = self.__generic(askQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinJSONLD_Unexpected(self):
result = self.__generic(askQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByGETinJSONLD_Unexpected_Conneg(self):
result = self.__generic(askQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinJSONLD_Unexpected(self):
result = self.__generic(askQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+xml
def testAskByPOSTinJSONLD_Unexpected_Conneg(self):
result = self.__generic(askQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByGETinUnknow(self):
result = self.__generic(askQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByGETinUnknow_Conneg(self):
result = self.__generic(askQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByPOSTinUnknow(self):
result = self.__generic(askQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByPOSTinUnknow_Conneg(self):
result = self.__generic(askQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
###################
#### CONSTRUCT ####
###################
def testConstructByGETinXML(self):
result = self.__generic(constructQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByGETinXML_Conneg(self):
result = self.__generic(constructQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML(self):
result = self.__generic(constructQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML_Conneg(self):
result = self.__generic(constructQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByGETinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByGETinRDFXML_Conneg(self):
result = self.__generic(constructQuery, RDFXML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByPOSTinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByPOSTinRDFXML_Conneg(self):
result = self.__generic(constructQuery, RDFXML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# turtle is not a valid alias
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. turtle is not a valid alias. Use content negotiation instead")
def testConstructByGETinTURTLE(self):
result = self.__generic(constructQuery, TURTLE, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
def testConstructByGETinTURTLE_Conneg(self):
result = self.__generic(constructQuery, TURTLE, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. turtle is not a valid alias. Use content negotiation instead")
def testConstructByPOSTinTURTLE(self):
result = self.__generic(constructQuery, TURTLE, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
def testConstructByPOSTinTURTLE_Conneg(self):
result = self.__generic(constructQuery, TURTLE, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. n3 is not a valid alias. Use content negotiation instead")
def testConstructByGETinN3(self):
result = self.__generic(constructQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
def testConstructByGETinN3_Conneg(self):
result = self.__generic(constructQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. n3 is not a valid alias. Use content negotiation instead")
def testConstructByPOSTinN3(self):
result = self.__generic(constructQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
def testConstructByPOSTinN3_Conneg(self):
result = self.__generic(constructQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# json-ld is not a valid alias. Use content negotiation instead
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. json-ld is not a valid alias. Use content negotiation instead")
def testConstructByGETinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json-ld is not a valid alias. Use content negotiation instead
def testConstructByGETinJSONLD_Conneg(self):
result = self.__generic(constructQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json-ld is not a valid alias. Use content negotiation instead
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. json-ld is not a valid alias. Use content negotiation instead")
def testConstructByPOSTinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json-ld is not a valid alias. Use content negotiation instead
def testConstructByPOSTinJSONLD_Conneg(self):
result = self.__generic(constructQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinCSV_Unexpected(self):
result = self.__generic(constructQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinCSV_Unexpected_Conneg(self):
result = self.__generic(constructQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinCSV_Unexpected(self):
result = self.__generic(constructQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinCSV_Unexpected_Conneg(self):
result = self.__generic(constructQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json is valid alias but returns application/sparql-results+json
@unittest.skip("Blazegraph returns application/sparql-results+json. It MUST return an RDF graph [RDF-CONCEPTS] serialized, for example, in the RDF/XML syntax [RDF-XML], or an equivalent RDF graph serialization, for SPARQL Query forms DESCRIBE and CONSTRUCT). See http://www.w3.org/TR/sparql11-protocol/#query-success")
def testConstructByGETinJSON_Unexpected(self):
result = self.__generic(constructQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByGETinJSON_Unexpected_Conneg(self):
result = self.__generic(constructQuery, JSON, GET , onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json is valid alias but returns application/sparql-results+json
@unittest.skip("Blazegraph returns application/sparql-results+json. It MUST return an RDF graph [RDF-CONCEPTS] serialized, for example, in the RDF/XML syntax [RDF-XML], or an equivalent RDF graph serialization, for SPARQL Query forms DESCRIBE and CONSTRUCT). See http://www.w3.org/TR/sparql11-protocol/#query-success")
def testConstructByPOSTinJSON_Unexpected(self):
result = self.__generic(constructQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testConstructByPOSTinJSON_Unexpected_Conneg(self):
result = self.__generic(constructQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByGETinUnknow(self):
result = self.__generic(constructQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByGETinUnknow_Conneg(self):
result = self.__generic(constructQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByPOSTinUnknow(self):
result = self.__generic(constructQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByPOSTinUnknow_Conneg(self):
result = self.__generic(constructQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
##################
#### DESCRIBE ####
##################
def testDescribeByGETinXML(self):
result = self.__generic(describeQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByGETinXML_Conneg(self):
result = self.__generic(describeQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML(self):
result = self.__generic(describeQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML_Conneg(self):
result = self.__generic(describeQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByGETinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByGETinRDFXML_Conneg(self):
result = self.__generic(describeQuery, RDFXML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByPOSTinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByPOSTinRDFXML_Conneg(self):
result = self.__generic(describeQuery, RDFXML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# turtle is not a valid alias
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. turtle is not a valid alias. Use content negotiation instead")
def testDescribeByGETinTURTLE(self):
result = self.__generic(describeQuery, TURTLE, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
def testDescribeByGETinTURTLE_Conneg(self):
result = self.__generic(describeQuery, TURTLE, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. turtle is not a valid alias. Use content negotiation instead")
def testDescribeByPOSTinTURTLE(self):
result = self.__generic(describeQuery, TURTLE, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
def testDescribeByPOSTinTURTLE_Conneg(self):
result = self.__generic(describeQuery, TURTLE, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. n3 is not a valid alias. Use content negotiation instead")
def testDescribeByGETinN3(self):
result = self.__generic(describeQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
def testDescribeByGETinN3_Conneg(self):
result = self.__generic(describeQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. n3 is not a valid alias. Use content negotiation instead")
def testDescribeByPOSTinN3(self):
result = self.__generic(describeQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
def testDescribeByPOSTinN3_Conneg(self):
result = self.__generic(describeQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. json-ld is not a valid alias. Use content negotiation instead")
def testDescribeByGETinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByGETinJSONLD_Conneg(self):
result = self.__generic(describeQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
@unittest.skip("Blazegraph does not support receiving unexpected 'format' values. json-ld is not a valid alias. Use content negotiation instead")
def testDescribeByPOSTinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinJSONLD_Conneg(self):
result = self.__generic(describeQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinCSV_Unexpected(self):
result = self.__generic(describeQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
# Returned application/rdf+xml
def testDescribeByGETinCSV_Unexpected_Conneg(self):
result = self.__generic(describeQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinCSV_Unexpected(self):
result = self.__generic(describeQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinCSV_Unexpected_Conneg(self):
result = self.__generic(describeQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json is valid alias but returns application/sparql-results+json
@unittest.skip("Blazegraph returns application/sparql-results+json. It MUST return an RDF graph [RDF-CONCEPTS] serialized, for example, in the RDF/XML syntax [RDF-XML], or an equivalent RDF graph serialization, for SPARQL Query forms DESCRIBE and CONSTRUCT). See http://www.w3.org/TR/sparql11-protocol/#query-success")
def testDescribeByGETinJSON_Unexpected(self):
result = self.__generic(describeQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByGETinJSON_Unexpected_Conneg(self):
result = self.__generic(describeQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json is valid alias but returns application/sparql-results+json
@unittest.skip("Blazegraph returns application/sparql-results+json. It MUST return an RDF graph [RDF-CONCEPTS] serialized, for example, in the RDF/XML syntax [RDF-XML], or an equivalent RDF graph serialization, for SPARQL Query forms DESCRIBE and CONSTRUCT). See http://www.w3.org/TR/sparql11-protocol/#query-success")
def testDescribeByPOSTinJSON_Unexpected(self):
result = self.__generic(describeQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is application/rdf+xml
def testDescribeByPOSTinJSON_Unexpected_Conneg(self):
result = self.__generic(describeQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByGETinUnknow(self):
result = self.__generic(describeQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByGETinUnknow_Conneg(self):
result = self.__generic(describeQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByPOSTinUnknow(self):
result = self.__generic(describeQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByPOSTinUnknow_Conneg(self):
result = self.__generic(describeQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
def testQueryBadFormed(self):
self.assertRaises(QueryBadFormed, self.__generic, queryBadFormed, XML, GET)
def testQueryManyPrefixes(self):
result = self.__generic(queryManyPrefixes, XML, GET)
@unittest.skip('Blazegraph. org.openrdf.query.MalformedQueryException: Multiple prefix declarations for prefix xxx')
def testQueryDuplicatedPrefix(self):
result = self.__generic(queryDuplicatedPrefix, XML, GET)
def testKeepAlive(self):
sparql = SPARQLWrapper(endpoint)
sparql.setQuery('SELECT * WHERE {?s ?p ?o} LIMIT 10')
sparql.setReturnFormat(JSON)
sparql.setMethod(GET)
sparql.setUseKeepAlive()
sparql.query()
sparql.query()
def testQueryWithComma_1(self):
result = self.__generic(queryWithCommaInCurie_1, XML, GET)
@unittest.skip('Blazegraph. parser error: Failed to decode SPARQL ID "dbpedia:Category\". See #94')
def testQueryWithComma_2(self):
result = self.__generic(queryWithCommaInCurie_2, XML, POST)
def testQueryWithComma_3(self):
result = self.__generic(queryWithCommaInUri, XML, GET)
if __name__ == "__main__":
unittest.main()
sparqlwrapper-1.8.5/test/fuseki2__v3_6_0__agrovoc__test.py 0000664 0000000 0000000 00000160202 13577650276 0023644 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#!/usr/bin/python
import inspect
import os
import sys
import unittest
# prefer local copy to the one which is installed
# hack from http://stackoverflow.com/a/6098238/280539
_top_level_path = os.path.realpath(os.path.abspath(os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0],
".."
)))
if _top_level_path not in sys.path:
sys.path.insert(0, _top_level_path)
# end of hack
import warnings
warnings.simplefilter("always")
try:
from rdflib.graph import ConjunctiveGraph
except ImportError:
from rdflib import ConjunctiveGraph
from SPARQLWrapper import SPARQLWrapper, XML, RDFXML, RDF, N3, TURTLE, JSONLD, JSON, CSV, TSV, POST, GET
from SPARQLWrapper.Wrapper import _SPARQL_XML, _SPARQL_JSON, _XML, _RDF_XML, _RDF_N3, _RDF_TURTLE, _RDF_JSONLD, _CSV, _TSV
from SPARQLWrapper.SPARQLExceptions import QueryBadFormed
_SPARQL_SELECT_ASK_POSSIBLE = _SPARQL_XML + _SPARQL_JSON + _CSV + _TSV + _XML # only used in test
_SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE = _RDF_XML + _RDF_N3 + _XML + _RDF_JSONLD # only used in test. Same as Wrapper._RDF_POSSIBLE
try:
from urllib.error import HTTPError # Python 3
except ImportError:
from urllib2 import HTTPError # Python 2
try:
bytes # Python 2.6 and above
except NameError:
bytes = str
import logging
logging.basicConfig()
endpoint = "http://agrovoc.uniroma2.it:3030/agrovoc/sparql" # Fuseki 3.6.0 (Fuseki2)
prefixes = """
PREFIX rdf:
PREFIX rdfs:
PREFIX skos:
"""
selectQuery = """
SELECT ?label
WHERE {
skos:prefLabel ?label .
}
"""
selectQueryCSV_TSV = """
SELECT ?label ?created
WHERE {
skos:prefLabel ?label ;
?created
}
"""
askQuery = """
ASK { a ?type }
"""
constructQuery = """
CONSTRUCT {
_:v skos:prefLabel ?label .
_:v rdfs:comment "this is only a mock node to test library"
}
WHERE {
skos:prefLabel ?label .
}
"""
describeQuery = """
DESCRIBE
"""
queryBadFormed = """
PREFIX prop:
PREFIX res:
FROM
SELECT ?lat ?long
WHERE {
res:Budapest prop:latitude ?lat;
prop:longitude ?long.
}
"""
queryManyPrefixes = """
PREFIX conf:
PREFIX meta:
PREFIX rdf:
PREFIX rdfs:
PREFIX xsd:
PREFIX owl:
PREFIX dc:
PREFIX dcterms:
PREFIX foaf:
PREFIX skos:
PREFIX geo:
PREFIX dbpedia:
PREFIX o:
PREFIX p:
PREFIX yago:
PREFIX units:
PREFIX geonames:
PREFIX prv:
PREFIX prvTypes:
PREFIX foo:
SELECT ?label
WHERE {
rdfs:label ?label .
}
"""
queryDuplicatedPrefix = """
PREFIX rdf:
PREFIX rdf:
SELECT ?s ?p ?o WHERE {
?s ?p ?o .
} LIMIT 10
"""
queryWithCommaInCurie_1 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Victoria\\,\\_British\\_Columbia .
?article ?title
}
"""
queryWithCommaInCurie_2 = """
PREFIX dbpedia:
SELECT ?article ?title WHERE {
?article ?relation dbpedia:Category\:Victoria\,\_British\_Columbia .
?article ?title
}
"""
queryWithCommaInUri = """
SELECT ?article ?title WHERE {
?article ?relation .
?article ?title
}
"""
class SPARQLWrapperTests(unittest.TestCase):
def __generic(self, query, returnFormat, method, onlyConneg=False): # Fuseki uses URL parameters OR content negotiation.
sparql = SPARQLWrapper(endpoint)
sparql.setQuery(prefixes + query)
sparql.setReturnFormat(returnFormat)
sparql.setMethod(method)
sparql.setOnlyConneg(onlyConneg)
try:
result = sparql.query()
except HTTPError:
# An ugly way to get the exception, but the only one that works
# both on Python 2.5 and Python 3.
e = sys.exc_info()[1]
if e.code == 400:
sys.stdout.write("400 Bad Request, probably query is not well formed")
elif e.code == 406:
sys.stdout.write("406 Not Acceptable, maybe query is not well formed")
else:
sys.stdout.write(str(e))
sys.stdout.write("\n")
return False
else:
return result
################################################################################
################################################################################
################
#### SELECT ####
################
def testSelectByGETinXML(self):
result = self.__generic(selectQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByGETinXML_Conneg(self):
result = self.__generic(selectQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML(self):
result = self.__generic(selectQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByPOSTinXML_Conneg(self):
result = self.__generic(selectQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testSelectByGETinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinCSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinCSV(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinCSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinTSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, TSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinTSV(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByPOSTinTSV_Conneg(self):
result = self.__generic(selectQueryCSV_TSV, TSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testSelectByGETinJSON(self):
result = self.__generic(selectQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByGETinJSON_Conneg(self):
result = self.__generic(selectQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON(self):
result = self.__generic(selectQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testSelectByPOSTinJSON_Conneg(self):
result = self.__generic(selectQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
@unittest.skip("fuseki2: Can't determine output serialization: n3")
def testSelectByGETinN3_Unexpected(self):
result = self.__generic(selectQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
def testSelectByGETinN3_Unexpected_Conneg(self):
result = self.__generic(selectQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
@unittest.skip("fuseki2: Can't determine output serialization: n3")
def testSelectByPOSTinN3_Unexpected(self):
result = self.__generic(selectQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (n3 is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
def testSelectByPOSTinN3_Unexpected_Conneg(self):
result = self.__generic(selectQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
@unittest.skip("fuseki2: Can't determine output serialization: json-ld")
def testSelectByGETinJSONLD_Unexpected(self):
result = self.__generic(selectQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
def testSelectByGETinJSONLD_Unexpected_Conneg(self):
result = self.__generic(selectQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
@unittest.skip("fuseki2: Can't determine output serialization: json-ld")
def testSelectByPOSTinJSONLD_Unexpected(self):
result = self.__generic(selectQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for SELECT queryType (json-ld is not supported, and it is not a valid alias).
# Set by default None (and sending */*).
# For a SELECT query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
def testSelectByPOSTinJSONLD_Unexpected_Conneg(self):
result = self.__generic(selectQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByGETinUnknow(self):
result = self.__generic(selectQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByGETinUnknow_Conneg(self):
result = self.__generic(selectQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByPOSTinUnknow(self):
result = self.__generic(selectQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for SELECT queryType (XML is sent)
def testSelectByPOSTinUnknow_Conneg(self):
result = self.__generic(selectQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
#############
#### ASK ####
#############
def testAskByGETinXML(self):
result = self.__generic(askQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByGETinXML_Conneg(self):
result = self.__generic(askQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML(self):
result = self.__generic(askQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByPOSTinXML_Conneg(self):
result = self.__generic(askQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_XML], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
def testAskByGETinCSV(self):
result = self.__generic(askQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinCSV_Conneg(self):
result = self.__generic(askQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByPOSTinCSV(self):
result = self.__generic(askQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByPOSTinCSV_Conneg(self):
result = self.__generic(askQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _CSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinTSV(self):
result = self.__generic(askQuery, TSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinTSV_Conneg(self):
result = self.__generic(askQuery, TSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByPOSTinTSV(self):
result = self.__generic(askQuery, TSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByPOSTinTSV_Conneg(self):
result = self.__generic(askQuery, TSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _TSV], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testAskByGETinJSON(self):
result = self.__generic(askQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByGETinJSON_Conneg(self):
result = self.__generic(askQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON(self):
result = self.__generic(askQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
def testAskByPOSTinJSON_Conneg(self):
result = self.__generic(askQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_JSON], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
@unittest.skip("fuseki2: Can't determine output serialization: n3")
def testAskByGETinN3_Unexpected(self):
result = self.__generic(askQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
def testAskByGETinN3_Unexpected_Conneg(self):
result = self.__generic(askQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
@unittest.skip("fuseki2: Can't determine output serialization: n3")
def testAskByPOSTinN3_Unexpected(self):
result = self.__generic(askQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (n3 is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
def testAskByPOSTinN3_Unexpected_Conneg(self):
result = self.__generic(askQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
@unittest.skip("fuseki2: Can't determine output serialization: json-ld")
def testAskByGETinJSONLD_Unexpected(self):
result = self.__generic(askQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
def testAskByGETinJSONLD_Unexpected_Conneg(self):
result = self.__generic(askQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
@unittest.skip("fuseki2: Can't determine output serialization: json-ld")
def testAskByPOSTinJSONLD_Unexpected(self):
result = self.__generic(askQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unexpected return format for ASK queryType (json-ld is not supported, it is not a valid alias).
# Set by default None (and sending */*).
# For an ASK query type, the default return mimetype (if Accept: */* is sent) is application/sparql-results+json
def testAskByPOSTinJSONLD_Unexpected_Conneg(self):
result = self.__generic(askQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), dict)
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByGETinUnknow(self):
result = self.__generic(askQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByGETinUnknow_Conneg(self):
result = self.__generic(askQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByPOSTinUnknow(self):
result = self.__generic(askQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
# Asking for an unknown return format for ASK queryType (XML is sent)
def testAskByPOSTinUnknow_Conneg(self):
result = self.__generic(askQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_SELECT_ASK_POSSIBLE], ct
results = result.convert()
self.assertEqual(results.__class__.__module__, "xml.dom.minidom")
self.assertEqual(results.__class__.__name__, "Document")
################################################################################
################################################################################
###################
#### CONSTRUCT ####
###################
def testConstructByGETinXML(self):
result = self.__generic(constructQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByGETinXML_Conneg(self):
result = self.__generic(constructQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML(self):
result = self.__generic(constructQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testConstructByPOSTinXML_Conneg(self):
result = self.__generic(constructQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: rdf+xml")
def testConstructByGETinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByGETinRDFXML_Conneg(self):
result = self.__generic(constructQuery, RDFXML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: rdf+xml")
def testConstructByPOSTinRDFXML(self):
result = self.__generic(constructQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testConstructByPOSTinRDFXML_Conneg(self):
result = self.__generic(constructQuery, RDFXML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# turtle is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: turtle")
def testConstructByGETinTURTLE(self):
result = self.__generic(constructQuery, TURTLE, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
def testConstructByGETinTURTLE_Conneg(self):
result = self.__generic(constructQuery, TURTLE, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: turtle")
def testConstructByPOSTinTURTLE(self):
result = self.__generic(constructQuery, TURTLE, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
def testConstructByPOSTinTURTLE_Conneg(self):
result = self.__generic(constructQuery, TURTLE, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: n3")
def testConstructByGETinN3(self):
result = self.__generic(constructQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
def testConstructByGETinN3_Conneg(self):
result = self.__generic(constructQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: n3")
def testConstructByPOSTinN3(self):
result = self.__generic(constructQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
def testConstructByPOSTinN3_Conneg(self):
result = self.__generic(constructQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# json-ld is not a valid alias. Use content negotiation instead
def testConstructByGETinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json-ld is not a valid alias. Use content negotiation instead
def testConstructByGETinJSONLD_Conneg(self):
result = self.__generic(constructQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json-ld is not a valid alias. Use content negotiation instead
def testConstructByPOSTinJSONLD(self):
result = self.__generic(constructQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# json-ld is not a valid alias. Use content negotiation instead
def testConstructByPOSTinJSONLD_Conneg(self):
result = self.__generic(constructQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle
@unittest.skip("fuseki2: Can't determine output content type: csv")
def testConstructByGETinCSV_Unexpected(self):
result = self.__generic(constructQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle
def testConstructByGETinCSV_Unexpected_Conneg(self):
result = self.__generic(constructQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle
@unittest.skip("fuseki2: Can't determine output content type: csv")
def testConstructByPOSTinCSV_Unexpected(self):
result = self.__generic(constructQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle
def testConstructByPOSTinCSV_Unexpected_Conneg(self):
result = self.__generic(constructQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# DIFFERENT: json is an alias of json-ld
def testConstructByGETinJSON_Unexpected(self):
result = self.__generic(constructQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle
def testConstructByGETinJSON_Unexpected_Conneg(self):
result = self.__generic(constructQuery, JSON, GET , onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# DIFFERENT: json is an alias of json-ld
def testConstructByPOSTinJSON_Unexpected(self):
result = self.__generic(constructQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for CONSTRUCT queryType.
# For a CONSTRUCT query type, the default return mimetype (if Accept: */* is sent) is text/turtle
def testConstructByPOSTinJSON_Unexpected_Conneg(self):
result = self.__generic(constructQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByGETinUnknow(self):
result = self.__generic(constructQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByGETinUnknow_Conneg(self):
result = self.__generic(constructQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByPOSTinUnknow(self):
result = self.__generic(constructQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for CONSTRUCT queryType (XML is sent)
def testConstructByPOSTinUnknow_Conneg(self):
result = self.__generic(constructQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
##################
#### DESCRIBE ####
##################
def testDescribeByGETinXML(self):
result = self.__generic(describeQuery, XML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByGETinXML_Conneg(self):
result = self.__generic(describeQuery, XML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML(self):
result = self.__generic(describeQuery, XML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinXML_Conneg(self):
result = self.__generic(describeQuery, XML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: rdf+xml")
def testDescribeByGETinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByGETinRDFXML_Conneg(self):
result = self.__generic(describeQuery, RDFXML, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: rdf+xml")
def testDescribeByPOSTinRDFXML(self):
result = self.__generic(describeQuery, RDFXML, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# rdf+xml is not a valid alias
def testDescribeByPOSTinRDFXML_Conneg(self):
result = self.__generic(describeQuery, RDFXML, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_XML], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# turtle is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: turtle")
def testDescribeByGETinTURTLE(self):
result = self.__generic(describeQuery, TURTLE, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
def testDescribeByGETinTURTLE_Conneg(self):
result = self.__generic(describeQuery, TURTLE, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: turtle")
def testDescribeByPOSTinTURTLE(self):
result = self.__generic(describeQuery, TURTLE, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# turtle is not a valid alias
def testDescribeByPOSTinTURTLE_Conneg(self):
result = self.__generic(describeQuery, TURTLE, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_TURTLE], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: n3")
def testDescribeByGETinN3(self):
result = self.__generic(describeQuery, N3, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
def testDescribeByGETinN3_Conneg(self):
result = self.__generic(describeQuery, N3, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
@unittest.skip("fuseki2: Can't determine output content type: n3")
def testDescribeByPOSTinN3(self):
result = self.__generic(describeQuery, N3, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
# n3 is not a valid alias
def testDescribeByPOSTinN3_Conneg(self):
result = self.__generic(describeQuery, N3, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_N3], ct
results = result.convert()
self.assertEqual(type(results), bytes)
def testDescribeByGETinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByGETinJSONLD_Conneg(self):
result = self.__generic(describeQuery, JSONLD, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinJSONLD(self):
result = self.__generic(describeQuery, JSONLD, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
def testDescribeByPOSTinJSONLD_Conneg(self):
result = self.__generic(describeQuery, JSONLD, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _RDF_JSONLD], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle
@unittest.skip("fuseki2: Can't determine output content type: csv")
def testDescribeByGETinCSV_Unexpected(self):
result = self.__generic(describeQuery, CSV, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle
def testDescribeByGETinCSV_Unexpected_Conneg(self):
result = self.__generic(describeQuery, CSV, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle
@unittest.skip("fuseki2: Can't determine output content type: csv")
def testDescribeByPOSTinCSV_Unexpected(self):
result = self.__generic(describeQuery, CSV, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle
def testDescribeByPOSTinCSV_Unexpected_Conneg(self):
result = self.__generic(describeQuery, CSV, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# DIFFERENT: json is an alias of json-ld
def testDescribeByGETinJSON_Unexpected(self):
result = self.__generic(describeQuery, JSON, GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle
def testDescribeByGETinJSON_Unexpected_Conneg(self):
result = self.__generic(describeQuery, JSON, GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# DIFFERENT: json is an alias of json-ld
def testDescribeByPOSTinJSON_Unexpected(self):
result = self.__generic(describeQuery, JSON, POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unexpected return format for DESCRIBE queryType.
# For a DESCRIBE query type, the default return mimetype (if Accept: */* is sent) is text/turtle
def testDescribeByPOSTinJSON_Unexpected_Conneg(self):
result = self.__generic(describeQuery, JSON, POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE]
results = result.convert()
self.assertEqual(type(results), bytes)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByGETinUnknow(self):
result = self.__generic(describeQuery, "foo", GET)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByGETinUnknow_Conneg(self):
result = self.__generic(describeQuery, "foo", GET, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByPOSTinUnknow(self):
result = self.__generic(describeQuery, "bar", POST)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
# Asking for an unknown return format for DESCRIBE queryType (XML is sent)
def testDescribeByPOSTinUnknow_Conneg(self):
result = self.__generic(describeQuery, "bar", POST, onlyConneg=True)
ct = result.info()["content-type"]
assert True in [one in ct for one in _SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE], ct
results = result.convert()
self.assertEqual(type(results), ConjunctiveGraph)
################################################################################
################################################################################
def testQueryBadFormed(self):
self.assertRaises(QueryBadFormed, self.__generic, queryBadFormed, XML, GET)
def testQueryManyPrefixes(self):
result = self.__generic(queryManyPrefixes, XML, GET)
def testQueryDuplicatedPrefix(self):
result = self.__generic(queryDuplicatedPrefix, XML, GET)
def testKeepAlive(self):
sparql = SPARQLWrapper(endpoint)
sparql.setQuery('SELECT * WHERE {?s ?p ?o} LIMIT 10')
sparql.setReturnFormat(JSON)
sparql.setMethod(GET)
sparql.setUseKeepAlive()
sparql.query()
sparql.query()
def testQueryWithComma_1(self):
result = self.__generic(queryWithCommaInCurie_1, XML, GET)
@unittest.skip('Fuseki Lexical error at line 8, column 45. Encountered: ":" (58), after : "\\". See #94')
def testQueryWithComma_2(self):
result = self.__generic(queryWithCommaInCurie_2, XML, POST)
def testQueryWithComma_3(self):
result = self.__generic(queryWithCommaInUri, XML, GET)
if __name__ == "__main__":
unittest.main()
sparqlwrapper-1.8.5/test/fuseki2__v3_8_0__stw__test.py 0000664 0000000 0000000 00000160265 13577650276 0023034 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#!/usr/bin/python
import time
import inspect
import os
import sys
import unittest
# prefer local copy to the one which is installed
# hack from http://stackoverflow.com/a/6098238/280539
_top_level_path = os.path.realpath(os.path.abspath(os.path.join(
os.path.split(inspect.getfile(inspect.currentframe()))[0],
".."
)))
if _top_level_path not in sys.path:
sys.path.insert(0, _top_level_path)
# end of hack
import warnings
warnings.simplefilter("always")
try:
from rdflib.graph import ConjunctiveGraph
except ImportError:
from rdflib import ConjunctiveGraph
from SPARQLWrapper import SPARQLWrapper, XML, RDFXML, RDF, N3, TURTLE, JSONLD, JSON, CSV, TSV, POST, GET
from SPARQLWrapper.Wrapper import _SPARQL_XML, _SPARQL_JSON, _XML, _RDF_XML, _RDF_N3, _RDF_TURTLE, _RDF_JSONLD, _CSV, _TSV
from SPARQLWrapper.SPARQLExceptions import QueryBadFormed
_SPARQL_SELECT_ASK_POSSIBLE = _SPARQL_XML + _SPARQL_JSON + _CSV + _TSV + _XML # only used in test
_SPARQL_DESCRIBE_CONSTRUCT_POSSIBLE = _RDF_XML + _RDF_N3 + _XML + _RDF_JSONLD # only used in test. Same as Wrapper._RDF_POSSIBLE
try:
from urllib.error import HTTPError # Python 3
except ImportError:
from urllib2 import HTTPError # Python 2
try:
bytes # Python 2.6 and above
except NameError:
bytes = str
import logging
logging.basicConfig()
endpoint = "http://zbw.eu/beta/sparql/stw/query" # Fuseki 3.8.0 (Fuseki2)
prefixes = """
PREFIX rdf: